mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2024-12-30 23:17:53 +02:00
350 lines
12 KiB
Lua
350 lines
12 KiB
Lua
local simplex_noise = require 'utils.simplex_noise'
|
|
simplex_noise = simplex_noise.d2
|
|
local f = {}
|
|
local math_random = math.random
|
|
local insert = table.insert
|
|
|
|
local function shuffle(tbl)
|
|
local size = #tbl
|
|
for i = size, 1, -1 do
|
|
local rand = math_random(size)
|
|
tbl[i], tbl[rand] = tbl[rand], tbl[i]
|
|
end
|
|
return tbl
|
|
end
|
|
|
|
f.draw_noise_tile_ring = function(surface, position, name, radius_min, radius_max)
|
|
local modifier_1 = math_random(2, 5) * 0.01
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
|
|
for y = radius_max * -2, radius_max * 2, 1 do
|
|
for x = radius_max * -2, radius_max * 2, 1 do
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local noise = simplex_noise(pos.x * modifier_1, pos.y * modifier_1, seed)
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
|
|
if distance_to_center + noise * radius_max * 0.25 < radius_max and distance_to_center + noise * radius_min * 0.25 > radius_min then
|
|
surface.set_tiles({{name = name, position = pos}}, true)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
f.draw_noise_entity_ring = function(surface, position, name, force, radius_min, radius_max)
|
|
local modifier_1 = 1 / (radius_max * 2)
|
|
local modifier_2 = 1 / (radius_max * 0.5)
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
|
|
for y = radius_max * -2, radius_max * 2, 1 do
|
|
for x = radius_max * -2, radius_max * 2, 1 do
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local noise = simplex_noise(pos.x * modifier_1, pos.y * modifier_1, seed) + simplex_noise(pos.x * modifier_2, pos.y * modifier_2, seed) * 0.2
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
|
|
if distance_to_center + noise * radius_max * 0.25 < radius_max and distance_to_center + noise * radius_min * 0.25 > radius_min then
|
|
if surface.can_place_entity({name = name, position = pos}) then
|
|
surface.create_entity({name = name, position = pos, force = force})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
f.draw_rainbow_patch = function(position, surface, radius, richness)
|
|
if not position then
|
|
return
|
|
end
|
|
if not surface then
|
|
return
|
|
end
|
|
if not radius then
|
|
return
|
|
end
|
|
if not richness then
|
|
return
|
|
end
|
|
local modifier_1 = math_random(3, 7)
|
|
local modifier_2 = math_random(1, 10) * 0.005
|
|
local modifier_3 = math_random(1, 10) * 0.05
|
|
local modifier_4 = math_random(5, 30) * 0.01
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
local ores = {'stone', 'coal', 'iron-ore', 'copper-ore'}
|
|
local richness_part = richness / (radius * 2)
|
|
for y = radius * -3, radius * 3, 1 do
|
|
for x = radius * -3, radius * 3, 1 do
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local noise = simplex_noise(pos.x * modifier_2, pos.y * modifier_2, seed) + simplex_noise(pos.x * modifier_3, pos.y * modifier_3, seed) * modifier_4
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
local ore = ores[(math.ceil(noise * modifier_1) % 4) + 1]
|
|
local amount = richness - richness_part * distance_to_center
|
|
if amount > 1 then
|
|
if surface.can_place_entity({name = ore, position = pos, amount = amount}) then
|
|
if distance_to_center + (noise * radius * 0.5) < radius then
|
|
surface.create_entity {name = ore, position = pos, amount = amount}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
f.draw_rainbow_patch_v2 = function(position, surface, radius, richness)
|
|
if not position then
|
|
return
|
|
end
|
|
if not surface then
|
|
return
|
|
end
|
|
if not radius then
|
|
return
|
|
end
|
|
if not richness then
|
|
return
|
|
end
|
|
local modifier_1 = math_random(2, 7)
|
|
local modifier_2 = math_random(100, 200) * 0.0002
|
|
local modifier_3 = math_random(100, 200) * 0.0015
|
|
local modifier_4 = math_random(15, 30) * 0.01
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
local ores = {'stone', 'coal', 'iron-ore', 'copper-ore'}
|
|
ores = shuffle(ores)
|
|
local richness_part = richness / (radius * 2)
|
|
for y = radius * -3, radius * 3, 1 do
|
|
for x = radius * -3, radius * 3, 1 do
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local noise = simplex_noise(pos.x * modifier_2, pos.y * modifier_2, seed) + simplex_noise(pos.x * modifier_3, pos.y * modifier_3, seed) * modifier_4
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
local ore = ores[(math.ceil(noise * modifier_1) % 4) + 1]
|
|
local amount = richness - richness_part * distance_to_center
|
|
if amount > 1 then
|
|
if surface.can_place_entity({name = ore, position = pos, amount = amount}) then
|
|
if distance_to_center + (noise * radius * 0.5) < radius then
|
|
surface.create_entity {name = ore, position = pos, amount = amount}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
f.draw_entity_circle = function(position, name, surface, radius, check_collision, amount)
|
|
if not position then
|
|
return
|
|
end
|
|
if not name then
|
|
return
|
|
end
|
|
if not surface then
|
|
return
|
|
end
|
|
if not radius then
|
|
return
|
|
end
|
|
for y = radius * -1, radius, 1 do
|
|
for x = radius * -1, radius, 1 do
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
if distance_to_center <= radius then
|
|
if check_collision then
|
|
if surface.can_place_entity({name = name, position = pos}) then
|
|
if amount then
|
|
surface.create_entity({name = name, position = pos, amount = amount})
|
|
else
|
|
surface.create_entity({name = name, position = pos})
|
|
end
|
|
end
|
|
else
|
|
if amount then
|
|
surface.create_entity({name = name, position = pos, amount = amount})
|
|
else
|
|
surface.create_entity({name = name, position = pos})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
f.draw_noise_tile_circle = function(position, name, surface, radius)
|
|
if not position then
|
|
return
|
|
end
|
|
if not name then
|
|
return
|
|
end
|
|
if not surface then
|
|
return
|
|
end
|
|
if not radius then
|
|
return
|
|
end
|
|
local noise_seed_add = 25000
|
|
local tiles = {}
|
|
for y = radius * -2, radius * 2, 1 do
|
|
for x = radius * -2, radius * 2, 1 do
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
local noise_1 = simplex_noise(pos.x * 0.05, pos.y * 0.05, seed)
|
|
seed = seed + noise_seed_add
|
|
local noise_2 = simplex_noise(pos.x * 0.1, pos.y * 0.1, seed)
|
|
local noise = noise_1 + noise_2 * 0.5
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
if distance_to_center + noise * radius * 0.3 < radius then
|
|
insert(tiles, {name = name, position = pos})
|
|
end
|
|
end
|
|
end
|
|
surface.set_tiles(tiles, true)
|
|
end
|
|
|
|
f.draw_oil_circle = function(position, name, surface, radius, richness)
|
|
if not position then
|
|
return
|
|
end
|
|
if not name then
|
|
return
|
|
end
|
|
if not surface then
|
|
return
|
|
end
|
|
if not radius then
|
|
return
|
|
end
|
|
if not richness then
|
|
return
|
|
end
|
|
local count = 0
|
|
local max_count = 0
|
|
while count < radius and max_count < 100000 do
|
|
for y = radius * -1, radius, 1 do
|
|
for x = radius * -1, radius, 1 do
|
|
if math_random(1, 200) == 1 then
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local a = math_random(richness * 0.5, richness * 1.5)
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
if distance_to_center < radius then
|
|
if surface.can_place_entity({name = name, position = pos, amount = a}) then
|
|
surface.create_entity {name = name, position = pos, amount = a}
|
|
count = count + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
max_count = max_count + 1
|
|
end
|
|
end
|
|
|
|
f.draw_smoothed_out_ore_circle = function(position, name, surface, radius, richness)
|
|
if not position then
|
|
return
|
|
end
|
|
if not name then
|
|
return
|
|
end
|
|
if not surface then
|
|
return
|
|
end
|
|
if not radius then
|
|
return
|
|
end
|
|
if not richness then
|
|
return
|
|
end
|
|
local noise_seed_add = 25000
|
|
local richness_part = richness / radius
|
|
for y = radius * -2, radius * 2, 1 do
|
|
for x = radius * -2, radius * 2, 1 do
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
local noise_1 = simplex_noise(pos.x * 0.08, pos.y * 0.08, seed)
|
|
seed = seed + noise_seed_add
|
|
local noise_2 = simplex_noise(pos.x * 0.15, pos.y * 0.15, seed)
|
|
local noise = noise_1 + noise_2 * 0.2
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
local a = richness - richness_part * distance_to_center
|
|
if distance_to_center + ((1 + noise) * 3) < radius and a > 1 then
|
|
if surface.can_place_entity({name = name, position = pos, amount = a}) then
|
|
surface.create_entity {name = name, position = pos, amount = a}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
f.draw_crazy_smoothed_out_ore_circle = function(position, name, surface, radius, richness)
|
|
if not position then
|
|
return
|
|
end
|
|
if not name then
|
|
return
|
|
end
|
|
if not surface then
|
|
return
|
|
end
|
|
if not radius then
|
|
return
|
|
end
|
|
if not richness then
|
|
return
|
|
end
|
|
local noise_seed_add = 25000
|
|
local richness_part = richness / radius
|
|
for y = radius * -1, radius, 1 do
|
|
for x = radius * -1, radius, 1 do
|
|
local pos = {x = x + position.x, y = y + position.y}
|
|
local seed = game.surfaces[1].map_gen_settings.seed
|
|
local noise_1 = simplex_noise(pos.x * 0.02, pos.y * 0.02, seed)
|
|
seed = seed + noise_seed_add
|
|
local noise_2 = simplex_noise(pos.x * 0.2, pos.y * 0.2, seed)
|
|
local noise = noise_1 + noise_2 * 0.2
|
|
local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
|
|
local a = richness - richness_part * distance_to_center
|
|
if distance_to_center < radius * noise and a > 1 then
|
|
if surface.can_place_entity({name = name, position = pos, amount = a}) then
|
|
surface.create_entity {name = name, position = pos, amount = a}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
f.create_cluster = function(name, pos, size, surface, spread, resource_amount)
|
|
local p = {x = pos.x, y = pos.y}
|
|
local original_pos = {x = pos.x, y = pos.y}
|
|
local entity_has_been_placed
|
|
for _ = 1, size, 1 do
|
|
entity_has_been_placed = false
|
|
local y = 1
|
|
if spread then
|
|
y = math_random(1, spread)
|
|
end
|
|
local modifier_raffle = {{0, y * -1}, {y * -1, 0}, {y, 0}, {0, y}, {y * -1, y * -1}, {y, y}, {y, y * -1}, {y * -1, y}}
|
|
modifier_raffle = shuffle(modifier_raffle)
|
|
for x = 1, 8, 1 do
|
|
local m = modifier_raffle[x]
|
|
pos = {x = p.x + m[1], y = p.y + m[2]}
|
|
if resource_amount then
|
|
if surface.can_place_entity({name = name, position = pos, amount = resource_amount}) then
|
|
surface.create_entity {name = name, position = pos, amount = resource_amount}
|
|
p = {x = pos.x, y = pos.y}
|
|
entity_has_been_placed = true
|
|
break
|
|
end
|
|
else
|
|
if surface.can_place_entity({name = name, position = pos}) then
|
|
surface.create_entity {name = name, position = pos}
|
|
p = {x = pos.x, y = pos.y}
|
|
entity_has_been_placed = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if entity_has_been_placed == false then
|
|
p = {x = original_pos.x, y = original_pos.y}
|
|
end
|
|
end
|
|
end
|
|
|
|
return f
|