mirror of
https://github.com/Refactorio/RedMew.git
synced 2024-12-16 10:19:27 +02:00
3f8be3151a
* Add redmew_surface * Change map_layout to have all maps use redmew_surface * Maps: switch hardcoded nauvis refs to redmew_surface * Features: switch hardcoded nauvis refs to redmew_surface * Per discussion, removal of RSO * Changes to files based on linting warnings/errors * ent_functions: remove functions from global scope, ignore remaining linting warnings (~100 remaining) * borg_planet: ignore linting warnings (88 remaining) * mazes refactored * Changed global.lua so events are run in the order they are registered
542 lines
19 KiB
Lua
542 lines
19 KiB
Lua
-- luacheck: ignore
|
|
-- This file contains many linting warnings and needs an overhaul
|
|
local RS = require 'map_gen.shared.redmew_surface'
|
|
--allows any gen to access these functions
|
|
|
|
local Public = {}
|
|
|
|
function Public.place_entities(surface, entity_list)
|
|
local directions = {defines.direction.north, defines.direction.east, defines.direction.south, defines.direction.west}
|
|
for _, entity in pairs(entity_list) do
|
|
local r = math.random(1,entity.chance)
|
|
if r == 1 then
|
|
if not entity.force then entity.force = "player" end
|
|
local r = math.random(1,4)
|
|
if surface.can_place_entity {name=entity.name, position=entity.pos, direction=directions[r], force=entity.force} then
|
|
local e = surface.create_entity {name=entity.name, position=entity.pos, direction=directions[r], force=entity.force}
|
|
if entity.health then
|
|
if entity.health == "low" then e.health = ((e.health / 1000) * math.random(33,330)) end
|
|
if entity.health == "medium" then e.health = ((e.health / 1000) * math.random(333,666)) end
|
|
if entity.health == "high" then e.health = ((e.health / 1000) * math.random(666,999)) end
|
|
if entity.health == "random" then e.health = ((e.health / 1000) * math.random(1,1000)) end
|
|
end
|
|
return true, e
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function Public.auto_place_entity_around_target(entity, scan_radius, mode, density, surface)
|
|
local x = entity.pos.x
|
|
local y = entity.pos.y
|
|
if not surface then surface = RS.get_surface() end
|
|
if not scan_radius then scan_radius = 6 end
|
|
if not entity then return end
|
|
if not mode then mode = "ball" end
|
|
if not density then density = 1 end
|
|
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
|
|
local i = 2
|
|
local r = 1
|
|
|
|
if mode == "ball" then
|
|
if math.random(1,2) == 1 then
|
|
density = density * -1
|
|
end
|
|
r = math.random(1,4)
|
|
end
|
|
if mode == "line" then
|
|
density = 1
|
|
r = math.random(1,4)
|
|
end
|
|
if mode == "line_down" then
|
|
density = density * -1
|
|
r = math.random(1,4)
|
|
end
|
|
if mode == "line_up" then
|
|
density = 1
|
|
r = math.random(1,4)
|
|
end
|
|
if mode == "block" then
|
|
r = 1
|
|
density = 1
|
|
end
|
|
|
|
if r == 1 then
|
|
--start placing at -1,-1
|
|
while i <= scan_radius do
|
|
y = y - density
|
|
x = x - density
|
|
for a = 1, i, 1 do
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
x = x + density
|
|
end
|
|
for a = 1, i, 1 do
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
y = y + density
|
|
end
|
|
for a = 1, i, 1 do
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
x = x - density
|
|
end
|
|
for a = 1, i, 1 do
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
y = y - density
|
|
end
|
|
i = i + 2
|
|
end
|
|
end
|
|
|
|
if r == 2 then
|
|
--start placing at 0,-1
|
|
while i <= scan_radius do
|
|
y = y - density
|
|
x = x - density
|
|
for a = 1, i, 1 do
|
|
x = x + density
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
y = y + density
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
x = x - density
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
y = y - density
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
end
|
|
i = i + 2
|
|
end
|
|
end
|
|
|
|
if r == 3 then
|
|
--start placing at 1,-1
|
|
while i <= scan_radius do
|
|
y = y - density
|
|
x = x + density
|
|
for a = 1, i, 1 do
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
y = y + density
|
|
end
|
|
for a = 1, i, 1 do
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
x = x - density
|
|
end
|
|
for a = 1, i, 1 do
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
y = y - density
|
|
end
|
|
for a = 1, i, 1 do
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
x = x + density
|
|
end
|
|
i = i + 2
|
|
end
|
|
end
|
|
|
|
if r == 4 then
|
|
--start placing at 1,0
|
|
while i <= scan_radius do
|
|
y = y - density
|
|
x = x + density
|
|
for a = 1, i, 1 do
|
|
y = y + density
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
x = x - density
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
y = y - density
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
x = x + density
|
|
if surface.can_place_entity {name=entity.name, position={x,y}} then
|
|
local e = surface.create_entity {name=entity.name, position={x,y}}
|
|
return true, e
|
|
end
|
|
end
|
|
i = i + 2
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function Public.create_entitie_cluster(name, pos, amount)
|
|
local surface = RS.get_surface()
|
|
local entity = {}
|
|
entity.pos = pos
|
|
entity.name = name
|
|
local mode = "ball"
|
|
|
|
for i = 1, amount, 1 do
|
|
local b, e = auto_place_entity_around_target(entity, 30, mode)
|
|
if b == true then
|
|
if 1 == math.random(1,40) then
|
|
entity.pos = e.position
|
|
end
|
|
if e.type == "resource" then
|
|
e.amount = math.random(500,1500)
|
|
end
|
|
end
|
|
end
|
|
return b, e
|
|
end
|
|
|
|
function Public.create_rock_cluster(pos, amount)
|
|
if not pos then return false end
|
|
if amount == nil then amount = 7 end
|
|
local scan_radius = amount * 2
|
|
local mode = "line_down"
|
|
if math.random(1,2) == 1 then mode = "line_up" end
|
|
local entity = {}
|
|
entity.pos = pos
|
|
for i = 1, amount, 1 do
|
|
if 1 == math.random(1,3) then
|
|
entity.name = "sand-rock-big"
|
|
else
|
|
entity.name = "sand-rock-big"
|
|
end
|
|
local b, e = auto_place_entity_around_target(entity, scan_radius, mode)
|
|
if b == true then
|
|
if 1 ~= math.random(1,20) then
|
|
entity.pos = e.position
|
|
end
|
|
end
|
|
end
|
|
return b, e
|
|
end
|
|
|
|
function Public.create_tree_cluster(pos, amount)
|
|
if not pos then return false end
|
|
if amount == nil then amount = 7 end
|
|
local scan_radius = amount * 2
|
|
--local mode = "line_down"
|
|
--if math.random(1,2) == 1 then mode = "line_up" end
|
|
local mode = "ball"
|
|
local entity = {}
|
|
entity.pos = pos
|
|
for i = 1, amount, 1 do
|
|
entity.name = "tree-06"
|
|
local density = 2
|
|
if 1 == math.random(1,20) then entity.name = "tree-07" end
|
|
if 1 == math.random(1,70) then entity.name = "tree-09" end
|
|
if 1 == math.random(1,10) then entity.name = "tree-04" end
|
|
if 1 == math.random(1,9) then density = 1 end
|
|
if 1 == math.random(1,3) then density = 3 end
|
|
if 1 == math.random(1,3) then density = 4 end
|
|
|
|
local b, e = auto_place_entity_around_target(entity, scan_radius, mode, density)
|
|
if b == true then
|
|
if 1 == math.random(1,3) then
|
|
entity.pos = e.position
|
|
end
|
|
end
|
|
end
|
|
return b, e
|
|
end
|
|
|
|
function Public.find_tile_placement_spot_around_target_position(tilename, position, mode, density)
|
|
local x = position.x
|
|
local y = position.y
|
|
if not surface then surface = RS.get_surface() end
|
|
local scan_radius = 50
|
|
if not tilename then return end
|
|
if not mode then mode = "ball" end
|
|
if not density then density = 1 end
|
|
local cluster_tiles = {}
|
|
local auto_correct = false
|
|
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,false)
|
|
return true, x, y
|
|
end
|
|
|
|
local i = 2
|
|
local r = 1
|
|
|
|
if mode == "ball" then
|
|
if math.random(1,2) == 1 then
|
|
density = density * -1
|
|
end
|
|
r = math.random(1,4)
|
|
end
|
|
if mode == "line" then
|
|
density = 1
|
|
r = math.random(1,4)
|
|
end
|
|
if mode == "line_down" then
|
|
density = density * -1
|
|
r = math.random(1,4)
|
|
end
|
|
if mode == "line_up" then
|
|
density = 1
|
|
r = math.random(1,4)
|
|
end
|
|
if mode == "block" then
|
|
r = 1
|
|
density = 1
|
|
end
|
|
|
|
if r == 1 then
|
|
--start placing at -1,-1
|
|
while i <= scan_radius do
|
|
y = y - density
|
|
x = x - density
|
|
for a = 1, i, 1 do
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
x = x + density
|
|
end
|
|
for a = 1, i, 1 do
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
y = y + density
|
|
end
|
|
for a = 1, i, 1 do
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
x = x - density
|
|
end
|
|
for a = 1, i, 1 do
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
y = y - density
|
|
end
|
|
i = i + 2
|
|
end
|
|
end
|
|
|
|
if r == 2 then
|
|
--start placing at 0,-1
|
|
while i <= scan_radius do
|
|
y = y - density
|
|
x = x - density
|
|
for a = 1, i, 1 do
|
|
x = x + density
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
y = y + density
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
x = x - density
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
y = y - density
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
end
|
|
i = i + 2
|
|
end
|
|
end
|
|
|
|
if r == 3 then
|
|
--start placing at 1,-1
|
|
while i <= scan_radius do
|
|
y = y - density
|
|
x = x + density
|
|
for a = 1, i, 1 do
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
y = y + density
|
|
end
|
|
for a = 1, i, 1 do
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
x = x - density
|
|
end
|
|
for a = 1, i, 1 do
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
y = y - density
|
|
end
|
|
for a = 1, i, 1 do
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
x = x + density
|
|
end
|
|
i = i + 2
|
|
end
|
|
end
|
|
|
|
if r == 4 then
|
|
--start placing at 1,0
|
|
while i <= scan_radius do
|
|
y = y - density
|
|
x = x + density
|
|
for a = 1, i, 1 do
|
|
y = y + density
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
x = x - density
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
y = y - density
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
end
|
|
for a = 1, i, 1 do
|
|
x = x + density
|
|
local scanned_tile = surface.get_tile(x,y)
|
|
if scanned_tile.name ~= tilename then
|
|
table.insert(cluster_tiles, {name = tilename, position = {x,y}})
|
|
surface.set_tiles(cluster_tiles,auto_correct)
|
|
return true, x, y
|
|
end
|
|
end
|
|
i = i + 2
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function Public.create_tile_cluster(tilename,position,amount)
|
|
local mode = "ball"
|
|
local cluster_tiles = {}
|
|
local surface = RS.get_surface()
|
|
local pos = position
|
|
local x = pos.x
|
|
local y = pos.y
|
|
for i = 1, amount, 1 do
|
|
local b,x,y = Public.find_tile_placement_spot_around_target_position(tilename, pos, mode)
|
|
if b == true then
|
|
if 1 == math.random(1,2) then
|
|
pos.x = x
|
|
pos.y = y
|
|
end
|
|
end
|
|
if b == false then return false,x,y end
|
|
if i >= amount then return true,x,y end
|
|
end
|
|
end
|
|
|
|
return Public
|