mirror of
https://github.com/Refactorio/RedMew.git
synced 2024-12-14 10:13:13 +02:00
1173 lines
41 KiB
Lua
1173 lines
41 KiB
Lua
-- Credit to the oarc folks, and jvmguy for getting an RSO version working in scenarios
|
|
-- To tie into this, maps must be generated with "NONE" for all resource ores
|
|
require("rso_config")
|
|
require("util")
|
|
require("rso_resource_config")
|
|
local Utils = require "utils.utils"
|
|
|
|
local MB=require "metaball"
|
|
local drand = require 'drand'
|
|
local rng = drand.mwvc
|
|
if not deterministic then rng = drand.sys_rand end
|
|
|
|
if not scenario then scenario = {} end
|
|
if not scenario.config then scenario.config = {} end
|
|
if not scenario.config.mapsettings then scenario.config.mapsettings = {} end
|
|
|
|
scenario.config.mapSettings = {
|
|
RSO_TERRAIN_SEGMENTATION = "very-low", -- Frequency of water
|
|
RSO_WATER = "high", -- Size of water patches
|
|
RSO_PEACEFUL = false, -- Peaceful mode for biters/aliens
|
|
RSO_STARTING_AREA = "very-low"
|
|
}
|
|
|
|
-- math shortcuts
|
|
local floor = math.floor
|
|
local abs = math.abs
|
|
local cos = math.cos
|
|
local sin = math.sin
|
|
local pi = math.pi
|
|
local max = math.max
|
|
|
|
local function rso_debug(str)
|
|
if rso_debug_enabled then
|
|
if (type(str) == "table") then
|
|
game.players[1].print(serpent.dump(str))
|
|
else
|
|
game.players[1].print(str)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- constants
|
|
local CHUNK_SIZE = 32
|
|
local REGION_TILE_SIZE = CHUNK_SIZE*region_size
|
|
local MIN_BALL_DISTANCE = CHUNK_SIZE/6
|
|
local P_BALL_SIZE_FACTOR = 0.7
|
|
local N_BALL_SIZE_FACTOR = 0.95
|
|
local NEGATIVE_MODIFICATOR = 123456
|
|
|
|
local meta_shapes = nil
|
|
|
|
if use_donut_shapes then
|
|
meta_shapes = {MB.MetaEllipse, MB.MetaSquare, MB.MetaDonut}
|
|
else
|
|
meta_shapes = {MB.MetaEllipse, MB.MetaSquare}
|
|
end
|
|
|
|
-- local globals
|
|
local index_is_built = false
|
|
local max_allotment = 0
|
|
local rgen = nil
|
|
local distance = util.distance
|
|
local spawner_probability_edge = 0 -- below this value a biter spawner, above/equal this value a spitter spawner
|
|
local invalidResources = {}
|
|
local config = nil
|
|
local configIndexed = nil
|
|
|
|
-- map gen settings mapping
|
|
|
|
local startingAreaMultiplier =
|
|
{
|
|
none = 0,
|
|
["very-low"] = 0.25,
|
|
low = 0.5,
|
|
normal = 1,
|
|
high = 1.5,
|
|
["very-high"] = 2,
|
|
}
|
|
|
|
local frequencyAllotmentMultiplier =
|
|
{
|
|
["very-low"] = 0.5,
|
|
low = 0.75,
|
|
normal = 1,
|
|
high = 1.5,
|
|
["very-high"] = 2,
|
|
}
|
|
|
|
local sizeMultiplier =
|
|
{
|
|
none = 0,
|
|
["very-low"] = 0.5,
|
|
low = 0.75,
|
|
normal = 1,
|
|
high = 1.25,
|
|
["very-high"] = 1.5,
|
|
}
|
|
|
|
local richnessMultiplier =
|
|
{
|
|
["very-low"] = 0.125,
|
|
low = 0.25,
|
|
normal = 1,
|
|
high = 2,
|
|
["very-high"] = 4,
|
|
}
|
|
|
|
local entityFrequencyMultiplier =
|
|
{
|
|
["very-low"] = 0.25,
|
|
low = 0.5,
|
|
normal = 1,
|
|
high = 2,
|
|
["very-high"] = 4,
|
|
}
|
|
|
|
local entitySizeMultiplier =
|
|
{
|
|
none = 0,
|
|
["very-low"] = 0.5,
|
|
low = 0.75,
|
|
normal = 1,
|
|
high = 2,
|
|
["very-high"] = 4,
|
|
}
|
|
|
|
--[[ HELPER METHODS ]]--
|
|
|
|
local function normalize(n) --keep numbers at (positive) 32 bits
|
|
return floor(n) % 0x80000000
|
|
end
|
|
|
|
local function bearing(origin, dest)
|
|
-- finds relative angle
|
|
local xd = dest.x - origin.x
|
|
local yd = dest.y - origin.y
|
|
return math.atan2(xd, yd);
|
|
end
|
|
|
|
local function str2num(s)
|
|
local num = 0
|
|
for i=1,s:len() do
|
|
num=num + (s:byte(i) - 33)*i
|
|
end
|
|
return num
|
|
end
|
|
|
|
local function mult_for_pos(pos)
|
|
local num = 0
|
|
local x = pos.x
|
|
local y = pos.y
|
|
|
|
if x == 0 then x = 0.5 end
|
|
if y == 0 then y = 0.5 end
|
|
if x < 0 then
|
|
x = abs(x) + NEGATIVE_MODIFICATOR
|
|
end
|
|
if y < 0 then
|
|
y = abs(y) + NEGATIVE_MODIFICATOR
|
|
end
|
|
|
|
return drand.lcg(y, 'mvc'):random(0)*drand.lcg(x, 'nr'):random(0)
|
|
end
|
|
|
|
local function rng_for_reg_pos(pos)
|
|
local rgen = rng(normalize(global.seed*mult_for_pos(pos)))
|
|
rgen:random()
|
|
rgen:random()
|
|
rgen:random()
|
|
return rgen
|
|
end
|
|
|
|
local function rng_restricted_angle(restrictions)
|
|
local rng = rgen:random()
|
|
local x_scale, y_scale
|
|
local deformX = rgen:random() * 2 - 1
|
|
local deformY = rgen:random() * 2 - 1
|
|
|
|
if restrictions=='xy' then
|
|
y_scale=1.0 + deformY*0.5
|
|
x_scale=1.0 + deformX*0.5
|
|
angle = rng*pi*2
|
|
elseif restrictions=='x' then
|
|
y_scale=1.0 + deformY*0.6
|
|
x_scale=1.0 + deformX*0.6
|
|
angle = rng*pi/2 - pi/4
|
|
elseif restrictions=='y' then
|
|
y_scale=1.0 + deformY*0.6
|
|
x_scale=1.0 + deformX*0.6
|
|
angle = rng*pi/2 + pi/2
|
|
else
|
|
y_scale=1.0 + deformY*0.3
|
|
x_scale=1.0 + deformX*0.3
|
|
angle = rng*pi*2
|
|
end
|
|
|
|
return angle, x_scale, y_scale
|
|
end
|
|
|
|
local function vary_by_percentage(x, p)
|
|
return x + (0.5 - rgen:random())*2*x*p
|
|
end
|
|
|
|
|
|
local function remove_trees(surface, x, y, x_size, y_size )
|
|
local bb={{x - x_size, y - y_size}, {x + x_size, y + y_size}}
|
|
for _, entity in pairs(surface.find_entities_filtered{area = bb, type="tree"}) do
|
|
if entity.valid then
|
|
entity.destroy()
|
|
end
|
|
end
|
|
end
|
|
|
|
local function find_intersection(surface, x, y)
|
|
-- try to get position in between of valid chunks by probing map
|
|
-- this may breaks determinism of generation, but so far it returned on first if
|
|
local gt = surface.get_tile
|
|
local restriction = ''
|
|
if gt(x + CHUNK_SIZE*2, y + CHUNK_SIZE*2).valid and gt(x - CHUNK_SIZE*2, y - CHUNK_SIZE*2).valid and gt(x + CHUNK_SIZE*2, y - CHUNK_SIZE*2).valid and gt(x - CHUNK_SIZE*2, y + CHUNK_SIZE*2).valid then
|
|
restriction = 'xy'
|
|
elseif gt(x + CHUNK_SIZE*2, y + CHUNK_SIZE*2).valid and gt(x + CHUNK_SIZE*2, y).valid and gt(x, y + CHUNK_SIZE*2).valid then
|
|
x=x + CHUNK_SIZE/2
|
|
y=y + CHUNK_SIZE/2
|
|
restriction = 'xy'
|
|
elseif gt(x + CHUNK_SIZE*2, y - CHUNK_SIZE*2).valid and gt(x + CHUNK_SIZE*2, y).valid and gt(x, y - CHUNK_SIZE*2).valid then
|
|
x=x + CHUNK_SIZE/2
|
|
y=y - CHUNK_SIZE/2
|
|
restriction = 'xy'
|
|
elseif gt(x - CHUNK_SIZE*2, y + CHUNK_SIZE*2).valid and gt(x - CHUNK_SIZE*2, y).valid and gt(x, y + CHUNK_SIZE*2).valid then
|
|
x=x - CHUNK_SIZE/2
|
|
y=y + CHUNK_SIZE/2
|
|
restriction = 'xy'
|
|
elseif gt(x - CHUNK_SIZE*2, y - CHUNK_SIZE*2).valid and gt(x - CHUNK_SIZE*2, y).valid and gt(x, y - CHUNK_SIZE*2).valid then
|
|
x=x - CHUNK_SIZE/2
|
|
y=y - CHUNK_SIZE/2
|
|
restriction = 'xy'
|
|
elseif gt(x + CHUNK_SIZE*2, y).valid then
|
|
x=x + CHUNK_SIZE/2
|
|
restriction = 'x'
|
|
elseif gt(x - CHUNK_SIZE*2, y).valid then
|
|
x=x - CHUNK_SIZE/2
|
|
restriction = 'x'
|
|
elseif gt(x, y + CHUNK_SIZE*2).valid then
|
|
y=y + CHUNK_SIZE/2
|
|
restriction = 'y'
|
|
elseif gt(x, y - CHUNK_SIZE*2).valid then
|
|
y=y - CHUNK_SIZE/2
|
|
restriction = 'y'
|
|
end
|
|
return x, y, restriction
|
|
end
|
|
|
|
local function find_random_chunk(r_x, r_y)
|
|
local offset_x=rgen:random(region_size)-1
|
|
local offset_y=rgen:random(region_size)-1
|
|
local c_x=r_x*REGION_TILE_SIZE + offset_x*CHUNK_SIZE
|
|
local c_y=r_y*REGION_TILE_SIZE + offset_y*CHUNK_SIZE
|
|
return c_x, c_y
|
|
end
|
|
|
|
local function is_same_region(c_x1, c_y1, c_x2, c_y2)
|
|
if not floor(c_x1/REGION_TILE_SIZE) == floor(c_x2/REGION_TILE_SIZE) then
|
|
return false
|
|
end
|
|
if not floor(c_y1/REGION_TILE_SIZE) == floor(c_y2/REGION_TILE_SIZE) then
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function find_random_neighbour_chunk(ocx, ocy)
|
|
-- somewhat bruteforce and unoptimized
|
|
local x_dir = rgen:random(-1,1)
|
|
local y_dir = rgen:random(-1,1)
|
|
local ncx = ocx + x_dir*CHUNK_SIZE
|
|
local ncy = ocy + y_dir*CHUNK_SIZE
|
|
if is_same_region(ncx, ncy, ocx, ocy) then
|
|
return ncx, ncy
|
|
end
|
|
|
|
ncx = ocx - x_dir*CHUNK_SIZE
|
|
ncy = ocy - y_dir*CHUNK_SIZE
|
|
if is_same_region(ncx, ncy, ocx, ocy) then
|
|
return ncx, ncy
|
|
end
|
|
|
|
ncx = ocx - x_dir*CHUNK_SIZE
|
|
if is_same_region(ncx, ocy, ocx, ocy) then
|
|
return ncx, ocy
|
|
end
|
|
|
|
ncy = ocy - y_dir*CHUNK_SIZE
|
|
if is_same_region(ocx, ncy, ocx, ocy) then
|
|
return ocx, ncy
|
|
end
|
|
|
|
return ocx, ocy
|
|
end
|
|
|
|
local function isInStartingArea( regionX, regionY )
|
|
for idx, pos in pairs( global.startingAreas ) do
|
|
|
|
local adjustedX = regionX - pos.x / REGION_TILE_SIZE
|
|
local adjustedY = regionY - pos.y / REGION_TILE_SIZE
|
|
if ((adjustedX * adjustedX + adjustedY * adjustedY) <= starting_area_size * starting_area_size) then
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
-- modifies the resource size - only used in endless_resource_mode
|
|
local function modify_resource_size(resourceName, resourceSize, startingArea)
|
|
|
|
if not startingArea then
|
|
resourceSize = math.ceil(resourceSize * global_size_mult)
|
|
end
|
|
|
|
resourceEntity = game.entity_prototypes[resourceName]
|
|
return resourceSize
|
|
end
|
|
|
|
--[[ SPAWN METHODS ]]--
|
|
|
|
local locationOrder =
|
|
{
|
|
{ x = 0, y = 0 },
|
|
{ x = -1, y = 0 },
|
|
{ x = 1, y = 0 },
|
|
{ x = 0, y = -1 },
|
|
{ x = 0, y = 1 },
|
|
{ x = -1, y = -1 },
|
|
{ x = 1, y = -1 },
|
|
{ x = -1, y = 1 },
|
|
{ x = 1, y = 1 }
|
|
}
|
|
|
|
--[[ entity-field ]]--
|
|
local function spawn_resource_ore(surface, rname, pos, size, richness, startingArea, restrictions)
|
|
-- blob generator, centered at pos, size controls blob diameter
|
|
restrictions = restrictions or ''
|
|
rso_debug("Entering spawn_resource_ore "..rname.." at:"..pos.x..","..pos.y.." size:"..size.." richness:"..richness.." isStart:"..tostring(startingArea).." restrictions:"..restrictions)
|
|
|
|
size = modify_resource_size(rname, size, startingArea)
|
|
local radius = size / 2 -- to radius
|
|
|
|
local p_balls={}
|
|
local n_balls={}
|
|
local MIN_BALL_DISTANCE = math.min(MIN_BALL_DISTANCE, radius/2)
|
|
|
|
local maxPradius = 0
|
|
local outside = { xmin = 1e10, xmax = -1e10, ymin = 1e10, ymax = -1e10 }
|
|
local inside = { xmin = 1e10, xmax = -1e10, ymin = 1e10, ymax = -1e10 }
|
|
|
|
local function adjustRadius(radius, scaleX, scaleY, up)
|
|
return radius
|
|
end
|
|
|
|
local function updateRect(rect, x, y, radius)
|
|
rect.xmin = math.min(rect.xmin, x - radius)
|
|
rect.xmax = math.max(rect.xmax, x + radius)
|
|
rect.ymin = math.min(rect.ymin, y - radius)
|
|
rect.ymax = math.max(rect.ymax, y + radius)
|
|
end
|
|
|
|
local function updateRects(x, y, radius, scaleX, scaleY)
|
|
local adjustedRadius = adjustRadius(radius, scaleX, scaleY, true)
|
|
local radiusMax = adjustedRadius * 3 -- arbitrary multiplier - needs to be big enough to not cut any metaballs
|
|
updateRect(outside, x, y, radiusMax)
|
|
updateRect(inside, x, y, adjustedRadius)
|
|
end
|
|
|
|
local function generate_p_ball()
|
|
local angle, x_scale, y_scale, x, y, b_radius, shape
|
|
angle, x_scale, y_scale=rng_restricted_angle(restrictions)
|
|
local dev = radius / 2 + rgen:random() * radius / 4--math.min(CHUNK_SIZE/3, radius*1.5)
|
|
local dev_x, dev_y = pos.x, pos.y
|
|
x = rgen:random(-dev, dev)+dev_x
|
|
y = rgen:random(-dev, dev)+dev_y
|
|
if p_balls[#p_balls] and Utils.distance(p_balls[#p_balls], {x=x, y=y}) < MIN_BALL_DISTANCE then
|
|
local new_angle = bearing(p_balls[#p_balls], {x=x, y=y})
|
|
rso_debug("Move ball old xy @ "..x..","..y)
|
|
x=(cos(new_angle)*MIN_BALL_DISTANCE) + x
|
|
y=(sin(new_angle)*MIN_BALL_DISTANCE) + y
|
|
rso_debug("Move ball new xy @ "..x..","..y)
|
|
end
|
|
|
|
if #p_balls == 0 then
|
|
b_radius = ( 3 * radius / 4 + rgen:random() * radius / 4) -- * (P_BALL_SIZE_FACTOR^#p_balls)
|
|
else
|
|
b_radius = ( radius / 4 + rgen:random() * radius / 2) -- * (P_BALL_SIZE_FACTOR^#p_balls)
|
|
end
|
|
|
|
|
|
if #p_balls > 0 then
|
|
local tempRect = table.deepcopy(inside)
|
|
updateRect(tempRect, x, y, adjustRadius(b_radius, x_scale, y_scale))
|
|
local rectSize = math.max(tempRect.xmax - tempRect.xmin, tempRect.ymax - tempRect.ymin)
|
|
local targetSize = size * 1.25
|
|
rso_debug("Rect size "..rectSize.." targetSize "..targetSize)
|
|
if rectSize > targetSize then
|
|
local widthLeft = (targetSize - (inside.xmax - inside.xmin))
|
|
local heightLeft = (targetSize - (inside.ymax - inside.ymin))
|
|
local widthMod = math.min(x - inside.xmin, inside.xmax - x)
|
|
local heightMod = math.min(y - inside.ymin, inside.ymax - y)
|
|
local radiusBackup = b_radius
|
|
b_radius = math.min(widthLeft + widthMod, heightLeft + heightMod)
|
|
b_radius = adjustRadius(b_radius, x_scale, y_scale, false)
|
|
rso_debug("Reduced ball radius from "..radiusBackup.." to "..b_radius.." widthLeft:"..widthLeft.." heightLeft:"..heightLeft.." widthMod:"..widthMod.." heightMod:"..heightMod)
|
|
end
|
|
end
|
|
|
|
if b_radius < 2 and #p_balls == 0 then
|
|
b_radius = 2
|
|
end
|
|
|
|
if b_radius > 0 then
|
|
|
|
maxPradius = math.max(maxPradius, b_radius)
|
|
shape = meta_shapes[rgen:random(1,#meta_shapes)]
|
|
local radiusText = ""
|
|
if shape.type == "MetaDonut" then
|
|
local inRadius = b_radius / 4 + b_radius / 2 * rgen:random()
|
|
radiusText = " inRadius:"..inRadius
|
|
p_balls[#p_balls+1] = shape:new(x, y, b_radius, inRadius, angle, x_scale, y_scale, 1.1)
|
|
else
|
|
p_balls[#p_balls+1] = shape:new(x, y, b_radius, angle, x_scale, y_scale, 1.1)
|
|
end
|
|
updateRects(x, y, b_radius, x_scale, y_scale)
|
|
|
|
rso_debug("P+Ball "..shape.type.." @ "..x..","..y.." radius: "..b_radius..radiusText.." angle: "..math.deg(angle).." scale: "..x_scale..", "..y_scale)
|
|
end
|
|
end
|
|
|
|
local function generate_n_ball(i)
|
|
local angle, x_scale, y_scale, x, y, b_radius, shape
|
|
angle, x_scale, y_scale=rng_restricted_angle('xy')
|
|
if p_balls[i] then
|
|
local new_angle = p_balls[i].angle + pi*rgen:random(0,1) + (rgen:random()-0.5)*pi/2
|
|
local dist = p_balls[i].radius
|
|
x=(cos(new_angle)*dist) + p_balls[i].x
|
|
y=(sin(new_angle)*dist) + p_balls[i].y
|
|
angle = p_balls[i].angle + pi/2 + (rgen:random()-0.5)*pi*2/3
|
|
else
|
|
x = rgen:random(-radius, radius)+pos.x
|
|
y = rgen:random(-radius, radius)+pos.y
|
|
end
|
|
|
|
if p_balls[i] then
|
|
b_radius = (p_balls[i].radius / 4 + rgen:random() * p_balls[i].radius / 2) -- * (N_BALL_SIZE_FACTOR^#n_balls)
|
|
else
|
|
b_radius = (radius / 4 + rgen:random() * radius / 2) -- * (N_BALL_SIZE_FACTOR^#n_balls)
|
|
end
|
|
|
|
if b_radius < 1 then
|
|
b_radius = 1
|
|
end
|
|
|
|
shape = meta_shapes[rgen:random(1,#meta_shapes)]
|
|
local radiusText = ""
|
|
if shape.type == "MetaDonut" then
|
|
local inRadius = b_radius / 4 + b_radius / 2 * rgen:random()
|
|
radiusText = " inRadius:"..inRadius
|
|
n_balls[#n_balls+1] = shape:new(x, y, b_radius, inRadius, angle, x_scale, y_scale, 1.15)
|
|
else
|
|
n_balls[#n_balls+1] = shape:new(x, y, b_radius, angle, x_scale, y_scale, 1.15)
|
|
end
|
|
-- updateRects(x, y, b_radius, x_scale, y_scale) -- should not be needed here - only positive ball can generate ore
|
|
rso_debug("N-Ball "..shape.type.." @ "..x..","..y.." radius: "..b_radius..radiusText.." angle: "..math.deg(angle).." scale: "..x_scale..", "..y_scale)
|
|
end
|
|
|
|
local function calculate_force(x,y)
|
|
local p_force = 0
|
|
local n_force = 0
|
|
for _,ball in ipairs(p_balls) do
|
|
p_force = p_force + ball:force(x,y)
|
|
end
|
|
for _,ball in ipairs(n_balls) do
|
|
n_force = n_force + ball:force(x,y)
|
|
end
|
|
local totalForce = 0
|
|
if p_force > n_force then
|
|
totalForce = 1 - 1/(p_force - n_force)
|
|
end
|
|
--rso_debug("Force at "..x..","..y.." p:"..p_force.." n:"..n_force.." result:"..totalForce)
|
|
--return (1 - 1/p_force) - n_force
|
|
return totalForce
|
|
end
|
|
|
|
local max_p_balls = 2
|
|
local min_amount = config[rname].min_amount or min_amount
|
|
if restrictions == 'xy' then
|
|
max_p_balls = 3
|
|
end
|
|
|
|
radius = math.min(radius, 2*CHUNK_SIZE)
|
|
|
|
local force
|
|
-- generate blobs
|
|
for i=1,max_p_balls do
|
|
generate_p_ball()
|
|
end
|
|
|
|
for i=1,rgen:random(1, #p_balls) do
|
|
generate_n_ball(i)
|
|
end
|
|
|
|
|
|
local _total = 0
|
|
local oreLocations = {}
|
|
local forceTotal = 0
|
|
|
|
-- fill the map
|
|
for y=outside.ymin, outside.ymax do
|
|
|
|
for x=outside.xmin, outside.xmax do
|
|
force = calculate_force(x, y)
|
|
if force > 0 then
|
|
oreLocations[#oreLocations + 1] = {x = x, y = y, force = force, valid = false}
|
|
forceTotal = forceTotal + force
|
|
end
|
|
end
|
|
end
|
|
|
|
local validCount, resOffsetX, resOffsetY, ratio
|
|
|
|
for _,locationOffset in ipairs(locationOrder) do
|
|
validCount = 0
|
|
resOffsetX = locationOffset.x * CHUNK_SIZE
|
|
resOffsetY = locationOffset.y * CHUNK_SIZE
|
|
|
|
for _, location in ipairs(oreLocations) do
|
|
|
|
local newX = location.x + resOffsetX
|
|
local newY = location.y + resOffsetY
|
|
location.valid = false
|
|
if surface.can_place_entity{name = rname, position = {x = newX,y = newY}} then
|
|
location.valid = true
|
|
validCount = validCount + 1
|
|
end
|
|
end
|
|
|
|
ratio = 0
|
|
|
|
if validCount > 0 then
|
|
ratio = validCount / #oreLocations
|
|
end
|
|
|
|
rso_debug("Valid ratio ".. ratio)
|
|
|
|
if not useResourceCollisionDetection then
|
|
break
|
|
end
|
|
|
|
if ratio > resourceCollisionDetectionRatio then
|
|
break
|
|
elseif resourceCollisionFieldSkip then -- in case no valid ratio was found we skip the field completely
|
|
validCount = 0
|
|
end
|
|
end
|
|
|
|
if validCount > 0 then
|
|
local rectSize = ((inside.xmax - inside.xmin) + (inside.ymax - inside.ymin)) / 2
|
|
|
|
local sizeMultiplier = rectSize ^ 0.6
|
|
local minSize = richness * 5 * sizeMultiplier
|
|
local maxSize = richness * 10 * sizeMultiplier
|
|
local approxDepositSize = rgen:random(minSize, maxSize)
|
|
|
|
approxDepositSize = approxDepositSize - validCount * min_amount
|
|
|
|
if approxDepositSize < 0 then
|
|
approxDepositSize = 100 * validCount
|
|
end
|
|
|
|
local forceFactor = approxDepositSize / forceTotal
|
|
|
|
-- don't create very dense resources in starting area - another field will be generated
|
|
if startingArea and forceFactor > 4000 then
|
|
forceFactor = rgen:random(3000, 4000)
|
|
end
|
|
|
|
rso_debug( "Force total:"..forceTotal.." sizeMin:"..minSize.." sizeMax:"..maxSize.." factor:"..forceFactor.." location#:"..validCount.." rectSize:"..rectSize.." sizeMultiplier:"..sizeMultiplier)
|
|
local richnessMultiplier = global_richness_mult
|
|
|
|
if startingArea then
|
|
richnessMultiplier = starting_richness_mult
|
|
end
|
|
|
|
-- infinite ore handling for Angels Ores mod
|
|
local spawnName = rname
|
|
|
|
for _,location in pairs(oreLocations) do
|
|
if location.valid then
|
|
|
|
local amount = floor(( forceFactor * location.force + min_amount ) * richnessMultiplier)
|
|
|
|
if amount > 1e9 then
|
|
amount = 1e9
|
|
end
|
|
|
|
_total = _total + amount
|
|
|
|
spawnName = rname
|
|
|
|
if amount > 0 then
|
|
surface.create_entity{name = spawnName,
|
|
position = {location.x + resOffsetX,location.y + resOffsetY},
|
|
force = game.forces.neutral,
|
|
amount = amount}
|
|
if removeTrees then
|
|
remove_trees(surface, location.x + resOffsetX, location.y + resOffsetY, 1, 1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
if rso_debug_enabled then
|
|
rso_debug("Total amount: ".._total)
|
|
rso_debug("Leaving spawn_resource_ore")
|
|
end
|
|
return _total
|
|
end
|
|
|
|
--[[ entity-liquid ]]--
|
|
local function spawn_resource_liquid(surface, rname, pos, size, richness, startingArea, restrictions)
|
|
restrictions = restrictions or ''
|
|
rso_debug("Entering spawn_resource_liquid "..rname.." "..pos.x..","..pos.y.." "..size.." "..richness.." "..tostring(startingArea).." "..restrictions)
|
|
local _total = 0
|
|
local max_radius = rgen:random()*CHUNK_SIZE/2 + CHUNK_SIZE
|
|
|
|
richness = ( 0.75 + rgen:random() / 2 ) * richness * size
|
|
|
|
resourceEntity = game.entity_prototypes[rname]
|
|
|
|
|
|
local total_share = 0
|
|
local avg_share = 1/size
|
|
local angle = rgen:random()*pi*2
|
|
local saved = 0
|
|
while total_share < 1 do
|
|
local new_share = vary_by_percentage(avg_share, 0.25)
|
|
if new_share + total_share > 1 then
|
|
new_share = 1 - total_share
|
|
end
|
|
|
|
total_share = new_share + total_share
|
|
if new_share < avg_share/10 then
|
|
-- too small
|
|
break
|
|
end
|
|
local amount = floor(richness*new_share) + saved
|
|
|
|
local richnessMultiplier = global_richness_mult
|
|
|
|
if startingArea then
|
|
richnessMultiplier = starting_richness_mult
|
|
end
|
|
|
|
--if amount >= game.entity_prototypes[rname].minimum then
|
|
if amount >= config[rname].minimum_amount then
|
|
saved = 0
|
|
for try=1,5 do
|
|
local dist = rgen:random()*(max_radius - max_radius*0.1)
|
|
angle = angle + pi/4 + rgen:random()*pi/2
|
|
local x, y = pos.x + cos(angle)*dist, pos.y + sin(angle)*dist
|
|
if surface.can_place_entity{name = rname, position = {x,y}} then
|
|
rso_debug("@ "..x..","..y.." amount: "..amount.." new_share: "..new_share.." try: "..try)
|
|
amount = floor(amount * richnessMultiplier)
|
|
|
|
if amount > 1e9 then
|
|
amount = 1e9
|
|
end
|
|
|
|
_total = _total + amount
|
|
|
|
if amount > 0 then
|
|
surface.create_entity{name = rname,
|
|
position = {x,y},
|
|
force = game.forces.neutral,
|
|
amount = amount,
|
|
direction = rgen:random(4)}
|
|
end
|
|
break
|
|
elseif not startingArea then -- we don't want to make ultra rich nodes in starting area - failing to make them will add second spawn in different location
|
|
entities = surface.find_entities_filtered{area = {{x-2.75, y-2.75}, {x+2.75, y+2.75}}, name=rname}
|
|
if entities and #entities > 0 then
|
|
_total = _total + amount
|
|
for k, ent in pairs(entities) do
|
|
ent.amount = ent.amount + floor(amount/#entities)
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
else
|
|
saved = amount
|
|
end
|
|
end
|
|
rso_debug("Total amount: ".._total)
|
|
rso_debug("Leaving spawn_resource_liquid")
|
|
return _total
|
|
end
|
|
|
|
--[[ EVENT/INIT METHODS ]]--
|
|
|
|
local function spawn_starting_resources( surface, index )
|
|
|
|
if global.startingAreas[index].spawned then return end
|
|
if surface.map_gen_settings.starting_area == "none" and not ignoreMapGenSettings then return end -- starting area disabled by map gen
|
|
if starting_area_size < 0.1 then return end -- skip spawning if starting area is to small
|
|
|
|
local position = global.startingAreas[index]
|
|
|
|
rso_debug(position)
|
|
rgen = rng_for_reg_pos( position )
|
|
local status = true
|
|
rso_debug(configIndexed)
|
|
|
|
for index,v in ipairs(configIndexed) do
|
|
if v.starting then
|
|
local prob = rgen:random() -- probability that this resource is spawned
|
|
rso_debug("starting resource probability rolled "..prob)
|
|
if v.starting.probability > 0 and prob <= v.starting.probability then
|
|
local total = 0
|
|
local radius = 25
|
|
local min_threshold = 0
|
|
|
|
if v.type == "resource-ore" then
|
|
min_threshold = v.starting.richness * rgen:random(5, 10) -- lets make sure that there is at least 10-15 times starting richness ore at start
|
|
elseif v.type == "resource-liquid" then
|
|
min_threshold = v.starting.richness * 0.5 * v.starting.size
|
|
end
|
|
rso_debug("Starting threshold: " .. min_threshold)
|
|
|
|
while (radius < 200) and (total < min_threshold) do
|
|
local angle = rgen:random() * pi * 2
|
|
local dist = rgen:random() * 30 + radius * 2
|
|
local pos = { x = floor(cos(angle) * dist) + position.x, y = floor(sin(angle) * dist) + position.y }
|
|
if v.type == "resource-ore" then
|
|
total = total + spawn_resource_ore(surface, v.name, pos, v.starting.size, v.starting.richness, true)
|
|
elseif v.type == "resource-liquid" then
|
|
total = total + spawn_resource_liquid(surface, v.name, pos, v.starting.size, v.starting.richness, true)
|
|
end
|
|
radius = radius + 10
|
|
end
|
|
if total < min_threshold then
|
|
status = false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
global.startingAreas[index].spawned = true
|
|
end
|
|
|
|
local function modifyMinMax(value, mod)
|
|
value.min = math.round( value.min * mod )
|
|
value.max = math.round( value.max * mod )
|
|
end
|
|
|
|
local function prebuild_config_data(surface)
|
|
if index_is_built then return false end
|
|
|
|
local mapGenSettings = nil
|
|
|
|
if not ignoreMapGenSettings then
|
|
mapGenSettings = surface.map_gen_settings
|
|
end
|
|
local autoPlaceSettings = nil
|
|
if mapGenSettings then
|
|
autoPlaceSettings = mapGenSettings.autoplace_controls
|
|
end
|
|
|
|
configIndexed = {}
|
|
-- build additional indexed array to the associative array
|
|
for res_name, res_conf in pairs(config) do
|
|
if res_conf.valid then -- only add valid resources
|
|
res_conf.name = res_name
|
|
|
|
local settingsForResource = nil
|
|
local isEntity = (res_conf.type == "entity")
|
|
local addResource = true
|
|
|
|
local autoplaceName = res_name
|
|
|
|
if res_conf.autoplace_name then
|
|
autoplaceName = res_conf.autoplace_name
|
|
end
|
|
|
|
if autoPlaceSettings then
|
|
settingsForResource = autoPlaceSettings[autoplaceName]
|
|
end
|
|
|
|
if settingsForResource then
|
|
local allotmentMod = nil
|
|
local sizeMod = nil
|
|
if isEntity then
|
|
allotmentMod = entityFrequencyMultiplier[settingsForResource.frequency]
|
|
sizeMod = entitySizeMultiplier[settingsForResource.size]
|
|
else
|
|
allotmentMod =frequencyAllotmentMultiplier[settingsForResource.frequency]
|
|
sizeMod = sizeMultiplier[settingsForResource.size]
|
|
end
|
|
|
|
local richnessMod = richnessMultiplier[settingsForResource.richness]
|
|
|
|
rso_debug(res_name .. " allotment mod " .. allotmentMod .. " size mod " .. sizeMod .. " richness mod " .. richnessMod )
|
|
|
|
if allotmentMod then
|
|
if isEntity then
|
|
res_conf.absolute_probability = res_conf.absolute_probability * allotmentMod
|
|
rso_debug("Entity chance modified to "..res_conf.absolute_probability)
|
|
else
|
|
res_conf.allotment = math.round( res_conf.allotment * allotmentMod )
|
|
end
|
|
end
|
|
|
|
if sizeMod ~= nil and sizeMod == 0 then
|
|
addResource = false
|
|
end
|
|
|
|
if sizeMod then
|
|
modifyMinMax(res_conf.size, sizeMod)
|
|
|
|
if res_conf.starting then
|
|
res_conf.starting.size = math.round( res_conf.starting.size * sizeMod )
|
|
end
|
|
|
|
if isEntity then
|
|
if res_conf.sub_spawn_size then
|
|
modifyMinMax(res_conf.sub_spawn_size, sizeMod)
|
|
end
|
|
modifyMinMax(res_conf.spawns_per_region, sizeMod)
|
|
end
|
|
end
|
|
|
|
if richnessMod then
|
|
if type == "resource-ore" then
|
|
res_conf.richness = math.round( res_conf.richness * richnessMod )
|
|
elseif type == "resource-liquid" then
|
|
modifyMinMax(res_conf.richness, richnessMod)
|
|
end
|
|
|
|
if res_conf.starting then
|
|
res_conf.starting.richness = math.round( res_conf.starting.richness * richnessMod )
|
|
end
|
|
end
|
|
end
|
|
|
|
if addResource then
|
|
configIndexed[#configIndexed + 1] = res_conf
|
|
if res_conf.multi_resource and multi_resource_active then
|
|
local new_list = {}
|
|
for sub_res_name, allotment in pairs(res_conf.multi_resource) do
|
|
if config[sub_res_name] and config[sub_res_name].valid then
|
|
new_list[#new_list+1] = {name = sub_res_name, allotment = allotment}
|
|
end
|
|
end
|
|
table.sort(new_list, function(a, b) return a.name < b.name end)
|
|
res_conf.multi_resource = new_list
|
|
else
|
|
res_conf.multi_resource_chance = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort(configIndexed, function(a, b) return a.name < b.name end)
|
|
|
|
local pr=0
|
|
for index,v in pairs(config) do
|
|
if v.along_resource_probability then
|
|
v.along_resource_probability_range={min=pr, max=pr+v.along_resource_probability}
|
|
pr=pr+v.along_resource_probability
|
|
end
|
|
if v.allotment and v.allotment > 0 then
|
|
v.allotment_range={min=max_allotment, max=max_allotment+v.allotment}
|
|
max_allotment=max_allotment+v.allotment
|
|
end
|
|
end
|
|
|
|
if mapGenSettings and mapGenSettings.starting_area then
|
|
local multiplier = startingAreaMultiplier[mapGenSettings.starting_area]
|
|
if multiplier ~= nil then
|
|
starting_area_size = starting_area_size * multiplier
|
|
rso_debug("Starting area "..starting_area_size)
|
|
end
|
|
end
|
|
|
|
index_is_built = true
|
|
end
|
|
|
|
|
|
local function checkConfigForInvalidResources()
|
|
--make sure that every resource in the config is actually available.
|
|
--call this function, before the auxiliary config is prebuilt!
|
|
if index_is_built then return end
|
|
|
|
local prototypes = game.entity_prototypes
|
|
|
|
for resourceName, resourceConfig in pairs(config) do
|
|
if prototypes[resourceName] or resourceConfig.type == "entity" then
|
|
resourceConfig.valid = true
|
|
else
|
|
-- resource was in config, but it doesn't exist in game files anymore - mark it invalid
|
|
resourceConfig.valid = false
|
|
|
|
table.insert(invalidResources, "Resource not available: " .. resourceName)
|
|
rso_debug("Resource not available: " .. resourceName)
|
|
end
|
|
|
|
if resourceConfig.valid and resourceConfig.type ~= "entity" then
|
|
if prototypes[resourceName].autoplace_specification == nil then
|
|
resourceConfig.valid = false
|
|
rso_debug("Resource "..resourceName.." invalidated - autoplace not present")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function roll_region(c_x, c_y)
|
|
--in what region is this chunk?
|
|
local r_x=floor(c_x/REGION_TILE_SIZE)
|
|
local r_y=floor(c_y/REGION_TILE_SIZE)
|
|
local r_data = nil
|
|
rso_debug("Region rolling...")
|
|
--don't spawn stuff in starting area
|
|
if isInStartingArea( c_x/REGION_TILE_SIZE, c_y/REGION_TILE_SIZE ) then
|
|
return false
|
|
end
|
|
|
|
if global.regions[r_x] and global.regions[r_x][r_y] then
|
|
r_data = global.regions[r_x][r_y]
|
|
else
|
|
--if this chunk is the first in its region to be generated
|
|
if not global.regions[r_x] then global.regions[r_x] = {} end
|
|
global.regions[r_x][r_y]={}
|
|
r_data = global.regions[r_x][r_y]
|
|
rgen = rng_for_reg_pos{x=r_x,y=r_y}
|
|
|
|
local rollCount = math.ceil(#configIndexed / 10) - 1 -- 0 based counter is more convenient here
|
|
rollCount = math.min(rollCount, 3)
|
|
|
|
for rollNumber = 0,rollCount do
|
|
|
|
local resourceChance = absolute_resource_chance - rollNumber * 0.1
|
|
--absolute chance to spawn resource
|
|
local abct = rgen:random()
|
|
rso_debug("Rolling resource "..abct.." against "..resourceChance.." roll "..rollNumber)
|
|
if abct <= resourceChance then
|
|
local res_type=rgen:random(1, max_allotment)
|
|
for index,v in ipairs(configIndexed) do
|
|
if v.allotment_range and ((res_type >= v.allotment_range.min) and (res_type <= v.allotment_range.max)) then
|
|
rso_debug("Rolled primary resource "..v.name.." with res_type="..res_type.." @ "..r_x..","..r_y)
|
|
local num_spawns=rgen:random(v.spawns_per_region.min, v.spawns_per_region.max)
|
|
local last_spawn_coords = {}
|
|
local along_
|
|
for i=1,num_spawns do
|
|
local c_x, c_y = find_random_chunk(r_x, r_y)
|
|
if not r_data[c_x] then r_data[c_x] = {} end
|
|
if not r_data[c_x][c_y] then r_data[c_x][c_y] = {} end
|
|
local c_data = r_data[c_x][c_y]
|
|
c_data[#c_data+1]={v.name, rollNumber}
|
|
last_spawn_coords[#last_spawn_coords+1] = {c_x, c_y}
|
|
rso_debug("Rolled primary chunk "..v.name.." @ "..c_x.."."..c_y.." reg: "..r_x..","..r_y)
|
|
-- Along resource spawn, only once
|
|
if i == 1 then
|
|
local am_roll = rgen:random()
|
|
for index,vv in ipairs(configIndexed) do
|
|
if vv.along_resource_probability_range and am_roll >= vv.along_resource_probability_range.min and am_roll <= vv.along_resource_probability_range.max then
|
|
c_data = r_data[c_x][c_y]
|
|
c_data[#c_data+1]={vv.name, rollNumber}
|
|
rso_debug("Rolled along "..vv.name.." @ "..c_x.."."..c_y.." reg: "..r_x..","..r_y)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- roll multiple resources in same region
|
|
local deep=0
|
|
while v.multi_resource_chance and rgen:random() <= v.multi_resource_chance*(multi_resource_chance_diminish^deep) do
|
|
deep = deep + 1
|
|
local max_allotment = 0
|
|
for index,sub_res in pairs(v.multi_resource) do max_allotment=max_allotment+sub_res.allotment end
|
|
|
|
local res_type=rgen:random(1, max_allotment)
|
|
local min=0
|
|
for _, sub_res in pairs(v.multi_resource) do
|
|
if (res_type >= min) and (res_type <= sub_res.allotment + min) then
|
|
local last_coords = last_spawn_coords[rgen:random(1, #last_spawn_coords)]
|
|
local c_x, c_y = find_random_neighbour_chunk(last_coords[1], last_coords[2]) -- in same as primary resource chunk
|
|
if not r_data[c_x] then r_data[c_x] = {} end
|
|
if not r_data[c_x][c_y] then r_data[c_x][c_y] = {} end
|
|
local c_data = r_data[c_x][c_y]
|
|
c_data[#c_data+1]={sub_res.name, deep}
|
|
rso_debug("Rolled multiple "..sub_res.name..":"..deep.." with res_type="..res_type.." @ "..c_x.."."..c_y.." reg: "..r_x.."."..r_y)
|
|
break
|
|
else
|
|
min = min + sub_res.allotment
|
|
end
|
|
end
|
|
end
|
|
break
|
|
end
|
|
end
|
|
|
|
end
|
|
end
|
|
-- roll for absolute_probability - this rolls the enemies
|
|
|
|
for index,v in ipairs(configIndexed) do
|
|
if v.absolute_probability then
|
|
local prob_factor = 1
|
|
if v.probability_distance_factor then
|
|
prob_factor = math.min(v.max_probability_distance_factor, v.probability_distance_factor^Utils.distance({x=0,y=0},{x=r_x,y=r_y}))
|
|
end
|
|
local abs_roll = rgen:random()
|
|
if abs_roll<v.absolute_probability*prob_factor then
|
|
local num_spawns=rgen:random(v.spawns_per_region.min, v.spawns_per_region.max)
|
|
for i=1,num_spawns do
|
|
local c_x, c_y = find_random_chunk(r_x, r_y)
|
|
if not r_data[c_x] then r_data[c_x] = {} end
|
|
if not r_data[c_x][c_y] then r_data[c_x][c_y] = {} end
|
|
c_data = r_data[c_x][c_y]
|
|
c_data[#c_data+1] = {v.name, 1}
|
|
rso_debug("Rolled absolute "..v.name.." with rt="..abs_roll.." @ "..c_x..","..c_y.." reg: "..r_x..","..r_y)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function roll_chunk(surface, c_x, c_y)
|
|
--handle spawn in chunks
|
|
local r_x=floor(c_x/REGION_TILE_SIZE)
|
|
local r_y=floor(c_y/REGION_TILE_SIZE)
|
|
local r_data = nil
|
|
|
|
--don't spawn stuff in starting area (RSO version of starting areas)
|
|
if isInStartingArea( c_x/REGION_TILE_SIZE, c_y/REGION_TILE_SIZE ) then
|
|
return false
|
|
end
|
|
|
|
local c_center_x=c_x + CHUNK_SIZE/2
|
|
local c_center_y=c_y + CHUNK_SIZE/2
|
|
|
|
if not (global.regions[r_x] and global.regions[r_x][r_y]) then
|
|
return
|
|
end
|
|
|
|
r_data = global.regions[r_x][r_y]
|
|
if not (r_data[c_x] and r_data[c_x][c_y]) then
|
|
return
|
|
end
|
|
if r_data[c_x] and r_data[c_x][c_y] then
|
|
rgen = rng_for_reg_pos{x=c_center_x,y=c_center_y}
|
|
|
|
rso_debug("Stumbled upon "..c_x..","..c_y.." reg: "..r_x.."."..r_y)
|
|
local resource_list = r_data[c_x][c_y]
|
|
--for resource, deep in pairs(r_data[c_x][c_y]) do
|
|
-- resource_list[#resource_list+1] = {resource, deep}
|
|
--end
|
|
table.sort(resource_list, function(res1, res2) return res1[2] < res2[2] end)
|
|
|
|
for _, res_con in ipairs(resource_list) do
|
|
local resource = res_con[1]
|
|
local deep = res_con[2]
|
|
local r_config = config[resource]
|
|
if r_config and r_config.valid then
|
|
local dist = Utils.distance({x=0,y=0},{x=r_x,y=r_y})
|
|
local sizeFactor = dist^size_distance_factor
|
|
if r_config.type=="resource-ore" then
|
|
local richFactor = dist^richness_distance_factor
|
|
rso_debug("Resource "..resource.." distance "..dist.." factors (size, richness) "..sizeFactor..","..richFactor)
|
|
local size=rgen:random(r_config.size.min, r_config.size.max) * (multi_resource_size_factor^deep) * sizeFactor
|
|
local richness = r_config.richness * richFactor * (multi_resource_richness_factor^deep)
|
|
local restriction = ''
|
|
rso_debug("Center @ "..c_center_x..","..c_center_y)
|
|
c_center_x, c_center_y, restriction = find_intersection(surface, c_center_x, c_center_y)
|
|
rso_debug("New Center @ "..c_center_x..","..c_center_y)
|
|
spawn_resource_ore(surface, resource, {x=c_center_x,y=c_center_y}, size, richness, false, restriction)
|
|
elseif r_config.type=="resource-liquid" then
|
|
local richFactor = dist^fluid_richness_distance_factor
|
|
rso_debug("Resource "..resource.." distance "..dist.." factors (size, richness) "..sizeFactor..","..richFactor)
|
|
local size=rgen:random(r_config.size.min, r_config.size.max) * (multi_resource_size_factor^deep) * sizeFactor
|
|
local richness=rgen:random(r_config.richness.min, r_config.richness.max) * richFactor * (multi_resource_richness_factor^deep)
|
|
local restriction = ''
|
|
c_center_x, c_center_y, restriction = find_intersection(surface, c_center_x, c_center_y)
|
|
spawn_resource_liquid(surface, resource, {x=c_center_x,y=c_center_y}, size, richness, false, restriction)
|
|
elseif r_config.type=="entity" then
|
|
if (not isNearSpawn) then
|
|
spawn_entity(surface, resource, r_config, c_center_x, c_center_y)
|
|
end
|
|
end
|
|
else
|
|
rso_debug("Resource access failed for " .. resource)
|
|
end
|
|
end
|
|
r_data[c_x][c_y]=nil
|
|
end
|
|
end
|
|
|
|
function RSO_init()
|
|
if not initDone then
|
|
|
|
local surface = game.surfaces["nauvis"]
|
|
|
|
if not global.regions then
|
|
global.regions = {}
|
|
end
|
|
|
|
if not config then
|
|
config = loadResourceConfig()
|
|
checkConfigForInvalidResources()
|
|
prebuild_config_data(surface)
|
|
end
|
|
|
|
global.seed = surface.map_gen_settings.seed
|
|
|
|
if not global.startingAreas then
|
|
global.startingAreas = {}
|
|
table.insert( global.startingAreas, { x = 0, y = 0, spawned = false } )
|
|
|
|
if global.start_resources_spawned or game.tick > 10 then
|
|
global.startingAreas[1].spawned = true
|
|
end
|
|
end
|
|
|
|
rso_debug("Starting resources...")
|
|
spawn_starting_resources(surface, 1 )
|
|
|
|
initDone = true
|
|
|
|
if surface.map_gen_settings.autoplace_controls["iron-ore"].size ~= "none" then
|
|
game.players[1].print("RSO WARNING - VANILLA iron-ore GEN IS NOT DISABLED!")
|
|
end
|
|
if surface.map_gen_settings.autoplace_controls["copper-ore"].size ~= "none" then
|
|
game.players[1].print("RSO WARNING - VANILLA copper-ore GEN IS NOT DISABLED!")
|
|
end
|
|
if surface.map_gen_settings.autoplace_controls["uranium-ore"].size ~= "none" then
|
|
game.players[1].print("RSO WARNING - VANILLA uranium-ore GEN IS NOT DISABLED!")
|
|
end
|
|
if surface.map_gen_settings.autoplace_controls["crude-oil"].size ~= "none" then
|
|
game.players[1].print("RSO WARNING - VANILLA crude-oil GEN IS NOT DISABLED!")
|
|
end
|
|
if surface.map_gen_settings.autoplace_controls["enemy-base"].size ~= "none" then
|
|
-- Not a problem, as this RSO does not gen biters
|
|
-- game.players[1].print("RSO WARNING - VANILLA enemy-base GEN IS NOT DISABLED!")
|
|
end
|
|
if surface.map_gen_settings.autoplace_controls["stone"].size ~= "none" then
|
|
game.players[1].print("RSO WARNING - VANILLA stone GEN IS NOT DISABLED!")
|
|
end
|
|
if surface.map_gen_settings.autoplace_controls["coal"].size ~= "none" then
|
|
game.players[1].print("RSO WARNING - VANILLA coal GEN IS NOT DISABLED!")
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
function run_ores_module(event) -- AKA RSO_ChunkGenerated(event)
|
|
local c_x = event.area.left_top.x
|
|
local c_y = event.area.left_top.y
|
|
|
|
RSO_init()
|
|
|
|
roll_region(c_x, c_y)
|
|
roll_chunk(event.surface, c_x, c_y)
|
|
end
|