games/RedMew
games/RedMew
1
0
Fork 0
mirror of https://github.com/Refactorio/RedMew.git synced 2025-01-30 04:30:58 +02:00
Code Issues Releases Activity

Merge branch 'develop' of https://github.com/grilledham/RedMew

Browse Source
This commit is contained in:
grilledham 2018-05-24 19:09:46 +01:00
commit 62ddc353a7
8 changed files with 851 additions and 1015 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
corpse_util.lua
View File

@ -1,5 +1,6 @@
local Event = require 'utils.event'
local Task = require 'utils.Task'
local Token = require 'utils.global_token'
local function on_init()
global.corpse_util_corpses = {}
@ -68,11 +69,14 @@ local function corpse_expired(event)
end
end
function corpse_util_mined_entity(data)
local corpse_util_mined_entity =
Token.register(
function(data)
if not data.entity.valid then
remove_tag(data.position)
end
end
end
)
local function mined_entity(event)
local entity = event.entity
@ -80,7 +84,7 @@ local function mined_entity(event)
if entity and entity.valid and entity.name == 'character-corpse' then
-- The corpse may be mined but not removed (if player doesn't have inventory space)
-- so we wait one tick to see if the corpse is gone.
Task.set_timeout_in_ticks(1, 'corpse_util_mined_entity', {entity = entity, position = entity.position})
Task.set_timeout_in_ticks(1, corpse_util_mined_entity, {entity = entity, position = entity.position})
end
end

374
custom_commands.lua
View File

@ -1,5 +1,6 @@
local Task = require "utils.Task"
local Event = require "utils.event"
local Task = require 'utils.Task'
local Event = require 'utils.event'
local Token = require 'utils.global_token'
function player_print(str)
if game.player then
@ -10,7 +11,7 @@ function player_print(str)
end
function cant_run(name)
player_print("Can't run command (" .. name .. ") - insufficient permission.")
player_print("Can't run command (" .. name .. ') - insufficient permission.')
end
local function invoke(cmd)
@ -18,14 +19,14 @@ local function invoke(cmd)
cant_run(cmd.name)
return
end
local target = cmd["parameter"]
local target = cmd['parameter']
if target == nil or game.players[target] == nil then
player_print("Unknown player.")
player_print('Unknown player.')
return
end
local pos = game.player.surface.find_non_colliding_position("player", game.player.position, 0, 1)
local pos = game.player.surface.find_non_colliding_position('player', game.player.position, 0, 1)
game.players[target].teleport({pos.x, pos.y}, game.player.surface)
game.print(target .. ", get your ass over here!")
game.print(target .. ', get your ass over here!')
end
local function teleport_player(cmd)
@ -33,13 +34,13 @@ local function teleport_player(cmd)
cant_run(cmd.name)
return
end
local target = cmd["parameter"]
local target = cmd['parameter']
if target == nil or game.players[target] == nil then
player_print("Unknown player.")
player_print('Unknown player.')
return
end
local surface = game.players[target].surface
local pos = surface.find_non_colliding_position("player", game.players[target].position, 0, 1)
local pos = surface.find_non_colliding_position('player', game.players[target].position, 0, 1)
game.player.teleport(pos, surface)
game.print(target .. "! watcha doin'?!")
end
@ -50,10 +51,10 @@ local function teleport_location(cmd)
return
end
if game.player.selected == nil then
player_print("Nothing selected.")
player_print('Nothing selected.')
return
end
local pos = game.player.surface.find_non_colliding_position("player", game.player.selected.position, 0, 1)
local pos = game.player.surface.find_non_colliding_position('player', game.player.selected.position, 0, 1)
game.player.teleport(pos)
end
@ -64,6 +65,24 @@ local function kill()
end
global.walking = {}
local custom_commands_return_player =
Token.register(
function(args)
global.walking[args.player.name:lower()] = false
args.player.character.destroy()
local character = args.player.surface.find_entity('player', args.position)
if character ~= nil and character.valid then
args.player.character = character
else
args.player.create_character()
end
args.player.force = args.force
args.player.teleport(args.position)
game.print(args.player.name .. ' came back from his walkabout.')
end
)
local function walkabout(cmd)
if not ((not game.player) or game.player.admin or is_mod(game.player.name)) then
cant_run(cmd.name)
@ -71,26 +90,30 @@ local function walkabout(cmd)
end
local params = {}
if cmd.parameter == nil then
player_print("Walkabout failed.")
player_print('Walkabout failed.')
return
end
for param in string.gmatch(cmd.parameter, "%S+") do table.insert(params, param) end
for param in string.gmatch(cmd.parameter, '%S+') do
table.insert(params, param)
end
local player_name = params[1]
local duration = 60
if #params > 2 then
player_print("Walkabout failed, check /help walkabout.")
player_print('Walkabout failed, check /help walkabout.')
return
elseif #params == 2 and tonumber(params[2]) == nil then
player_print(params[2] .. " is not a number.")
player_print(params[2] .. ' is not a number.')
return
elseif #params == 2 and tonumber(params[2]) then
duration = tonumber(params[2])
end
if duration < 15 then duration = 15 end
if duration < 15 then
duration = 15
end
local player = game.players[player_name]
if type(player) ~= "table" or global.walking[player_name:lower()] then
player_print(player_name .. " could not go on a walkabout.")
if type(player) ~= 'table' or global.walking[player_name:lower()] then
player_print(player_name .. ' could not go on a walkabout.')
return
end
local chunks = {}
@ -102,36 +125,26 @@ local function walkabout(cmd)
if not chunk then
return
end
local pos = {x=chunk.x * 32, y=chunk.y * 32}
local non_colliding_pos = player.surface.find_non_colliding_position("player", pos, 100, 1)
local pos = {x = chunk.x * 32, y = chunk.y * 32}
local non_colliding_pos = player.surface.find_non_colliding_position('player', pos, 100, 1)
if non_colliding_pos then
game.print(player_name .. " went on a walkabout, to find himself.")
Task.set_timeout(duration, "custom_commands_return_player", {player = player, force = player.force, position = {x = player.position.x, y = player.position.y}})
game.print(player_name .. ' went on a walkabout, to find himself.')
Task.set_timeout(
duration,
custom_commands_return_player,
{player = player, force = player.force, position = {x = player.position.x, y = player.position.y}}
)
player.character = nil
player.create_character()
player.teleport(non_colliding_pos)
player.force = "enemy"
player.force = 'enemy'
global.walking[player_name:lower()] = true
else
player_print("Walkabout failed: count find non colliding position")
player_print('Walkabout failed: count find non colliding position')
end
end
function custom_commands_return_player(args)
global.walking[args.player.name:lower()] = false
args.player.character.destroy()
local character = args.player.surface.find_entity('player', args.position)
if character ~= nil and character.valid then
args.player.character = character
else
args.player.create_character()
end
args.player.force = args.force
args.player.teleport(args.position)
game.print(args.player.name .. " came back from his walkabout.")
end
local function regular(cmd)
if not ((not game.player) or game.player.admin or is_mod(game.player.name)) then
cant_run(cmd.name)
@ -139,20 +152,22 @@ local function regular(cmd)
end
if cmd.parameter == nil then
player_print("Command failed. Usage: /regular <promote, demote>, <player>")
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
return
end
local params = {}
for param in string.gmatch(cmd.parameter, "%S+") do table.insert(params, param) end
for param in string.gmatch(cmd.parameter, '%S+') do
table.insert(params, param)
end
if params[2] == nil then
player_print("Command failed. Usage: /regular <promote, demote>, <player>")
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
return
elseif (params[1] == "promote") then
elseif (params[1] == 'promote') then
add_regular(params[2])
elseif (params[1] == "demote") then
elseif (params[1] == 'demote') then
remove_regular(params[2])
else
player_print("Command failed. Usage: /regular <promote, demote>, <player>")
player_print('Command failed. Usage: /regular <promote, demote>, <player>')
end
end
@ -163,35 +178,37 @@ local function mod(cmd)
end
if cmd.parameter == nil then
player_print("Command failed. Usage: /mod <promote, demote>, <player>")
player_print('Command failed. Usage: /mod <promote, demote>, <player>')
return
end
local params = {}
for param in string.gmatch(cmd.parameter, "%S+") do table.insert(params, param) end
for param in string.gmatch(cmd.parameter, '%S+') do
table.insert(params, param)
end
if params[2] == nil then
player_print("Command failed. Usage: /mod <promote, demote>, <player>")
player_print('Command failed. Usage: /mod <promote, demote>, <player>')
return
elseif (params[1] == "promote") then
elseif (params[1] == 'promote') then
add_mod(params[2])
elseif (params[1] == "demote") then
elseif (params[1] == 'demote') then
remove_mod(params[2])
else
player_print("Command failed. Usage: /mod <promote, demote>, <player>")
player_print('Command failed. Usage: /mod <promote, demote>, <player>')
end
end
local function afk()
for _,v in pairs (game.players) do
for _, v in pairs(game.players) do
if v.afk_time > 300 then
local time = " "
local time = ' '
if v.afk_time > 21600 then
time = time .. math.floor(v.afk_time / 216000) .. " hours "
time = time .. math.floor(v.afk_time / 216000) .. ' hours '
end
if v.afk_time > 3600 then
time = time .. math.floor(v.afk_time / 3600) % 60 .. " minutes and "
time = time .. math.floor(v.afk_time / 3600) % 60 .. ' minutes and '
end
time = time .. math.floor(v.afk_time / 60) % 60 .. " seconds."
player_print(v.name .. " has been afk for" .. time)
time = time .. math.floor(v.afk_time / 60) % 60 .. ' seconds.'
player_print(v.name .. ' has been afk for' .. time)
end
end
end
@ -203,15 +220,17 @@ local function tag(cmd)
end
if cmd.parameter ~= nil then
local params = {}
for param in string.gmatch(cmd.parameter, "%S+") do table.insert(params, param) end
for param in string.gmatch(cmd.parameter, '%S+') do
table.insert(params, param)
end
if #params < 2 then
player_print("Usage: <player> <tag> Sets a players tag.")
player_print('Usage: <player> <tag> Sets a players tag.')
elseif game.players[params[1]] == nil then
player_print("Player does not exist.")
player_print('Player does not exist.')
else
local tag = string.sub(cmd.parameter, params[1]:len() + 2)
game.players[params[1]].tag = "[" .. tag .. "]"
game.print(params[1] .. " joined [" .. tag .. "].")
game.players[params[1]].tag = '[' .. tag .. ']'
game.print(params[1] .. ' joined [' .. tag .. '].')
end
else
player_print('Usage: /tag <player> <tag> Sets a players tag.')
@ -227,7 +246,7 @@ local function follow(cmd)
global.follows[game.player.name] = cmd.parameter
global.follows.n_entries = global.follows.n_entries + 1
else
player_print("Usage: /follow <player> makes you follow the player. Use /unfollow to stop following a player.")
player_print('Usage: /follow <player> makes you follow the player. Use /unfollow to stop following a player.')
end
end
@ -249,7 +268,9 @@ local function built_entity(event)
if global.tp_players[index] then
local entity = event.created_entity
if entity.type ~= "entity-ghost" then return end
if entity.type ~= 'entity-ghost' then
return
end
game.players[index].teleport(entity.position)
entity.destroy()
@ -269,10 +290,10 @@ local function toggle_tp_mode(cmd)
if toggled then
global.tp_players[index] = nil
player_print("tp mode is now off")
player_print('tp mode is now off')
else
global.tp_players[index] = true
player_print("tp mode is now on - place a ghost entity to teleport there.")
player_print('tp mode is now on - place a ghost entity to teleport there.')
end
end
@ -301,31 +322,31 @@ local function forcetoggle(cmd)
end
end
if game.player.force.name == "enemy" then
if game.player.force.name == 'enemy' then
local old_force = global.old_force[game.player.name]
if not old_force then
game.player.force = "player"
game.player.force = 'player'
game.player.print("You're are now on the player force.")
else
if game.forces[old_force] then
game.player.force = old_force
else
game.player.force = "player"
game.player.force = 'player'
end
end
else
--Put roboports into inventory
inv = game.player.get_inventory(defines.inventory.player_armor)
if inv[1].valid_for_read
then
if inv[1].valid_for_read then
local name = inv[1].name
if name:match("power") or name:match("modular") then
if name:match('power') or name:match('modular') then
local equips = inv[1].grid.equipment
for _,equip in pairs(equips) do
if equip.name == "personal-roboport-equipment"
or equip.name == "personal-roboport-mk2-equipment"
or equip.name == "personal-laser-defense-equipment" then
if game.player.insert{name = equip.name} == 0 then
for _, equip in pairs(equips) do
if
equip.name == 'personal-roboport-equipment' or equip.name == 'personal-roboport-mk2-equipment' or
equip.name == 'personal-laser-defense-equipment'
then
if game.player.insert {name = equip.name} == 0 then
game.player.surface.spill_item_stack(game.player.position, {name = equip.name})
end
inv[1].grid.take(equip)
@ -335,39 +356,44 @@ local function forcetoggle(cmd)
end
global.old_force[game.player.name] = game.player.force.name
game.player.force = "enemy"
game.player.force = 'enemy'
end
game.player.print("You are now on the " .. game.player.force.name .. " force.")
game.player.print('You are now on the ' .. game.player.force.name .. ' force.')
-- Attempt to rebuild the request slots
slot_counts = game.player.character.request_slot_count
if game.player.character.request_slot_count > 0 then
for _,slot in ipairs(slots) do
for _, slot in ipairs(slots) do
game.player.character.set_request_slot(slot, _)
end
end
end
local function get_group()
local group = game.permissions.get_group("Banned")
local group = game.permissions.get_group('Banned')
if not group then
game.permissions.create_group("Banned")
group = game.permissions.get_group("Banned")
game.permissions.create_group('Banned')
group = game.permissions.get_group('Banned')
if group then
for i=2,174 do
for i = 2, 174 do
group.set_allows_action(i, false)
end
else
game.print("This would have nearly crashed the server, please consult the next best scenario dev (valansch or TWLtriston).")
game.print(
'This would have nearly crashed the server, please consult the next best scenario dev (valansch or TWLtriston).'
)
end
end
return group
end
function custom_commands_untempban(param)
game.print(param.name .. " is out of timeout.")
game.permissions.get_group("Default").add_player(param.name)
end
local custom_commands_untempban =
Token.register(
function(param)
game.print(param.name .. ' is out of timeout.')
game.permissions.get_group('Default').add_player(param.name)
end
)
local function tempban(cmd)
if (not game.player) or not (game.player.admin or is_mod(game.player.name)) then
@ -375,13 +401,15 @@ local function tempban(cmd)
return
end
if cmd.parameter == nil then
player_print("Tempban failed. Usage: /tempban <player> <minutes> Temporarily bans a player.")
player_print('Tempban failed. Usage: /tempban <player> <minutes> Temporarily bans a player.')
return
end
local params = {}
for param in string.gmatch(cmd.parameter, "%S+") do table.insert(params, param) end
for param in string.gmatch(cmd.parameter, '%S+') do
table.insert(params, param)
end
if #params < 2 or not tonumber(params[2]) then
player_print("Tempban failed. Usage: /tempban <player> <minutes> Temporarily bans a player.")
player_print('Tempban failed. Usage: /tempban <player> <minutes> Temporarily bans a player.')
return
end
if not game.players[params[1]] then
@ -389,43 +417,81 @@ local function tempban(cmd)
return
end
local group = get_group()
game.print(get_actor() .. " put " .. params[1] .. " in timeout for " .. params[2] .. " minutes.")
game.print(get_actor() .. ' put ' .. params[1] .. ' in timeout for ' .. params[2] .. ' minutes.')
if group then
group.add_player(params[1])
if not tonumber(cmd.parameter) then
Task.set_timeout(60 * tonumber(params[2]), "custom_commands_untempban", {name = params[1]})
Task.set_timeout(60 * tonumber(params[2]), custom_commands_untempban, {name = params[1]})
end
end
end
function custom_commands_replace_ghosts(param)
for _,ghost in pairs(param.ghosts) do
local new_ghost = game.surfaces[param.surface_index].create_entity{name = "entity-ghost", position = ghost.position, inner_name = ghost.ghost_name, expires = false, force = "enemy", direction = ghost.direction}
local custom_commands_replace_ghosts =
Token.register(
function(param)
for _, ghost in pairs(param.ghosts) do
local new_ghost =
game.surfaces[param.surface_index].create_entity {
name = 'entity-ghost',
position = ghost.position,
inner_name = ghost.ghost_name,
expires = false,
force = 'enemy',
direction = ghost.direction
}
new_ghost.last_user = ghost.last_user
end
end
end
)
local function spyshot(cmd)
if not cmd then return 0 end
if not cmd then
return 0
end
local player_name = cmd.parameter
if player_name and game.players[player_name] then
for _,spy in pairs(global.spys) do
for _, spy in pairs(global.spys) do
if game.players[spy] and game.players[spy].connected then
local pos = game.players[player_name].position
pseudo_ghosts = {}
for _,ghost in pairs(game.players[player_name].surface.find_entities_filtered{area = {{pos.x - 60, pos.y - 35},{pos.x + 60, pos.y + 35}},name = "entity-ghost", force = enemy}) do
local pseudo_ghost = {position = ghost.position, ghost_name = ghost.ghost_name, expires = false, force = "enemy", direction = ghost.direction, last_user = ghost.last_user}
for _, ghost in pairs(
game.players[player_name].surface.find_entities_filtered {
area = {{pos.x - 60, pos.y - 35}, {pos.x + 60, pos.y + 35}},
name = 'entity-ghost',
force = enemy
}
) do
local pseudo_ghost = {
position = ghost.position,
ghost_name = ghost.ghost_name,
expires = false,
force = 'enemy',
direction = ghost.direction,
last_user = ghost.last_user
}
table.insert(pseudo_ghosts, pseudo_ghost)
ghost.destroy()
end
game.take_screenshot{by_player = spy, position = pos, show_gui = false, show_entity_info = true, resolution = {1920, 1080}, anti_alias = true, zoom = 0.5, path ="spyshot.png"}
game.players[spy].print("You just took a screenshot!")
Task.set_timeout(2, "custom_commands_replace_ghosts", {ghosts = pseudo_ghosts, surface_index = game.players[player_name].surface.index}) --delay replacements for the screenshot to render
game.take_screenshot {
by_player = spy,
position = pos,
show_gui = false,
show_entity_info = true,
resolution = {1920, 1080},
anti_alias = true,
zoom = 0.5,
path = 'spyshot.png'
}
game.players[spy].print('You just took a screenshot!')
Task.set_timeout(
2,
custom_commands_replace_ghosts,
{ghosts = pseudo_ghosts, surface_index = game.players[player_name].surface.index}
) --delay replacements for the screenshot to render
return
end
end
player_print("No spy online!")
player_print('No spy online!')
end
end
@ -437,47 +503,89 @@ end
local function pool()
if game.player and game.player.admin then
local t = {} p = game.player.position
local t = {}
p = game.player.position
for x = p.x - 3, p.x + 3 do
for y = p.y + 2, p.y + 7 do
table.insert(t, {name="water", position={x,y}})
table.insert(t, {name = 'water', position = {x, y}})
end
end
game.player.surface.set_tiles(t)
game.player.surface.create_entity{name = "fish", position = {p.x + 0.5, p.y + 5}}
game.player.surface.create_entity {name = 'fish', position = {p.x + 0.5, p.y + 5}}
end
end
if not _DEBUG then
local old_add_command = commands.add_command
commands.add_command = function(name, desc, func)
old_add_command(name, desc, function(cmd)
commands.add_command =
function(name, desc, func)
old_add_command(
name,
desc,
function(cmd)
local success, error = pcall(func, cmd)
if not success then
log(error)
end
end)
end
)
end
end
commands.add_command("kill", "Will kill you.", kill)
commands.add_command("tpplayer", "<player> - Teleports you to the player. (Admins and moderators)", teleport_player)
commands.add_command("invoke", "<player> - Teleports the player to you. (Admins and moderators)", invoke)
commands.add_command("tppos", "Teleports you to a selected entity. (Admins only)", teleport_location)
commands.add_command("walkabout", '<player> <duration> - Send someone on a walk. (Admins and moderators)', walkabout)
commands.add_command("regulars", 'Prints a list of game regulars.', print_regulars)
commands.add_command("regular", '<promote, demote>, <player> Change regular status of a player. (Admins and moderators)', regular)
commands.add_command("mods", 'Prints a list of game mods.', print_mods)
commands.add_command("mod", '<promote, demote>, <player> Changes moderator status of a player. (Admins only)', mod)
commands.add_command("afk", 'Shows how long players have been afk.', afk)
commands.add_command('kill', 'Will kill you.', kill)
commands.add_command('tpplayer', '<player> - Teleports you to the player. (Admins and moderators)', teleport_player)
commands.add_command('invoke', '<player> - Teleports the player to you. (Admins and moderators)', invoke)
commands.add_command('tppos', 'Teleports you to a selected entity. (Admins only)', teleport_location)
commands.add_command('walkabout', '<player> <duration> - Send someone on a walk. (Admins and moderators)', walkabout)
commands.add_command('regulars', 'Prints a list of game regulars.', print_regulars)
commands.add_command(
'regular',
'<promote, demote>, <player> Change regular status of a player. (Admins and moderators)',
regular
)
commands.add_command('mods', 'Prints a list of game mods.', print_mods)
commands.add_command('mod', '<promote, demote>, <player> Changes moderator status of a player. (Admins only)', mod)
commands.add_command('afk', 'Shows how long players have been afk.', afk)
--commands.add_command("tag", '<player> <tag> Sets a players tag. (Admins only)', tag)
commands.add_command("follow", '<player> makes you follow the player. Use /unfollow to stop following a player.', follow)
commands.add_command("unfollow", 'stops following a player.', unfollow)
commands.add_command("tpmode", "Toggles tp mode. When on place a ghost entity to teleport there (Admins and moderators)", toggle_tp_mode)
commands.add_command("forcetoggle", "Toggles the players force between player and enemy (Admins and moderators)", forcetoggle)
commands.add_command("tempban", "<player> <minutes> Temporarily bans a player (Admins and moderators)", tempban)
commands.add_command("spyshot", "<player> Sends a screenshot of player to discord. (If a host is online. If no host is online, you can become one yourself. Ask on discord :))", spyshot)
commands.add_command("zoom", "<number> Sets your zoom.", zoom)
commands.add_command("all-tech", "researches all technologies", function() if game.player and game.player.admin then game.player.force.research_all_technologies() end end)
commands.add_command("hax", "Toggles your hax", function() if game.player and game.player.admin then game.player.cheat_mode = not game.player.cheat_mode end end)
commands.add_command("pool", "Spawns a pool", pool)
commands.add_command(
'follow',
'<player> makes you follow the player. Use /unfollow to stop following a player.',
follow
)
commands.add_command('unfollow', 'stops following a player.', unfollow)
commands.add_command(
'tpmode',
'Toggles tp mode. When on place a ghost entity to teleport there (Admins and moderators)',
toggle_tp_mode
)
commands.add_command(
'forcetoggle',
'Toggles the players force between player and enemy (Admins and moderators)',
forcetoggle
)
commands.add_command('tempban', '<player> <minutes> Temporarily bans a player (Admins and moderators)', tempban)
commands.add_command(
'spyshot',
'<player> Sends a screenshot of player to discord. (If a host is online. If no host is online, you can become one yourself. Ask on discord :))',
spyshot
)
commands.add_command('zoom', '<number> Sets your zoom.', zoom)
commands.add_command(
'all-tech',
'researches all technologies',
function()
if game.player and game.player.admin then
game.player.force.research_all_technologies()
end
end
)
commands.add_command(
'hax',
'Toggles your hax',
function()
if game.player and game.player.admin then
game.player.cheat_mode = not game.player.cheat_mode
end
end
)
commands.add_command('pool', 'Spawns a pool', pool)

607
map_gen/combined/borg_planet_v2.lua
View File

@ -2,10 +2,9 @@
-- !! ATTENTION !!
-- Use water only in starting area as map setting!!!
local perlin = require 'map_gen.shared.perlin_noise'
local Task = require 'utils.Task'
local Token = require 'utils.global_token'
wreck_item_pool = {}
wreck_item_pool = {
local wreck_item_pool = {
{name = 'iron-gear-wheel', count = 32},
{name = 'iron-plate', count = 64},
{name = 'rocket-control-unit', count = 1},
@ -35,387 +34,101 @@ wreck_item_pool = {
{name = 'explosive-rocket', count = 32}
}
local function 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
local ship_callback =
Token.register(
function(entity)
entity.health = math.random(entity.health)
local function find_tile_placement_spot_around_target_position(tilename, position, mode, density)
local x = position.x
local y = position.y
if not surface then
surface = game.surfaces[1]
entity.insert(wreck_item_pool[math.random(#wreck_item_pool)])
entity.insert(wreck_item_pool[math.random(#wreck_item_pool)])
entity.insert(wreck_item_pool[math.random(#wreck_item_pool)])
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 = true
)
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
local clear_types = {'simple-entity', 'tree'}
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
local function create_tile_cluster(tilename, position, amount)
local mode = 'ball'
local cluster_tiles = {}
local surface = game.surfaces[1]
local pos = position
local x = pos.x
local y = pos.y
for i = 1, amount, 1 do
local b, x, y = 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
function run_combined_module(event)
local area = event.area
local surface = event.surface
local entities = surface.find_entities(area)
for _, entity in pairs(entities) do
if entity.type == 'simple-entity' or entity.type == 'tree' then
if entity.name ~= 'dry-tree' then
local function do_clear_entities(world)
local entities = world.surface.find_entities_filtered({area = world.area, type = clear_types})
for _, entity in ipairs(entities) do
entity.destroy()
end
end
end
for x = 0, 31, 1 do
Task.queue_task('run_borg', {area = event.area, surface = event.surface, x = x})
end
end
function run_borg(params)
local tiles = {}
local decoratives = {}
local random_health =
Token.register(
function(e)
e.health = math.random(e.health)
end
)
local area = params.area
local surface = params.surface
local medium_health =
Token.register(
function(e)
e.health = math.random(math.floor(e.health * 0.333), math.floor(e.health * 0.666))
end
)
local x = params.x
local pos_x = area.left_top.x + x
local low_health =
Token.register(
function(e)
e.health = math.random(math.floor(e.health * 0.033), math.floor(e.health * 0.330))
end
)
local turrent_callback =
Token.register(
function(e)
if math.random(1, 3) == 1 then
e.insert('piercing-rounds-magazine')
else
e.insert('firearm-magazine')
end
end
)
return function(x, y, world)
local entities = {}
local area = world.area
local surface = world.surface
if not world.island_resort_cleared then
world.island_resort_cleared = true
do_clear_entities(world)
end
for y = 0, 31, 1 do
local pos_y = area.left_top.y + y
local pos = {x = pos_x, y = pos_y}
local tile = surface.get_tile(pos_x, pos_y)
local tile_to_insert = 'sand-1'
local entity_placed = false
local seed_increment_number = 10000
local seed = surface.map_gen_settings.seed
local noise_borg_defense_1 = perlin:noise(((pos_x + seed) / 100), ((pos_y + seed) / 100), 0)
local noise_borg_defense_1 = perlin:noise(((world.x + seed) / 100), ((world.y + seed) / 100), 0)
seed = seed + seed_increment_number
local noise_borg_defense_2 = perlin:noise(((pos_x + seed) / 20), ((pos_y + seed) / 20), 0)
local noise_borg_defense_2 = perlin:noise(((world.x + seed) / 20), ((world.y + seed) / 20), 0)
seed = seed + seed_increment_number
local noise_borg_defense = noise_borg_defense_1 + noise_borg_defense_2 * 0.15
local noise_trees_1 = perlin:noise(((pos_x + seed) / 50), ((pos_y + seed) / 50), 0)
local noise_trees_1 = perlin:noise(((world.x + seed) / 50), ((world.y + seed) / 50), 0)
seed = seed + seed_increment_number
local noise_trees_2 = perlin:noise(((pos_x + seed) / 15), ((pos_y + seed) / 15), 0)
local noise_trees_2 = perlin:noise(((world.x + seed) / 15), ((world.y + seed) / 15), 0)
seed = seed + seed_increment_number
local noise_trees = noise_trees_1 + noise_trees_2 * 0.3
local noise_walls_1 = perlin:noise(((pos_x + seed) / 150), ((pos_y + seed) / 150), 0)
local noise_walls_1 = perlin:noise(((world.x + seed) / 150), ((world.y + seed) / 150), 0)
seed = seed + seed_increment_number
local noise_walls_2 = perlin:noise(((pos_x + seed) / 50), ((pos_y + seed) / 50), 0)
local noise_walls_2 = perlin:noise(((world.x + seed) / 50), ((world.y + seed) / 50), 0)
seed = seed + seed_increment_number
local noise_walls_3 = perlin:noise(((pos_x + seed) / 20), ((pos_y + seed) / 20), 0)
local noise_walls_3 = perlin:noise(((world.x + seed) / 20), ((world.y + seed) / 20), 0)
seed = seed + seed_increment_number
local noise_walls = noise_walls_1 + noise_walls_2 * 0.1 + noise_walls_3 * 0.03
if noise_borg_defense > 0.66 then
local entity_list = {}
table.insert(entity_list, {name = 'big-ship-wreck-1', pos = {pos_x, pos_y}, chance = 25})
table.insert(entity_list, {name = 'big-ship-wreck-2', pos = {pos_x, pos_y}, chance = 25})
table.insert(entity_list, {name = 'big-ship-wreck-3', pos = {pos_x, pos_y}, chance = 25})
local b, placed_entity = place_entities(surface, entity_list)
if b == true then
if
placed_entity.name == 'big-ship-wreck-1' or placed_entity.name == 'big-ship-wreck-2' or
placed_entity.name == 'big-ship-wreck-3'
then
placed_entity.insert(wreck_item_pool[math.random(1, #wreck_item_pool)])
placed_entity.insert(wreck_item_pool[math.random(1, #wreck_item_pool)])
placed_entity.insert(wreck_item_pool[math.random(1, #wreck_item_pool)])
end
if math.random(25) == 1 then
table.insert(entities, {name = 'big-ship-wreck-1', force = 'player', callback = ship_callback})
elseif math.random(25) == 1 then
table.insert(entities, {name = 'big-ship-wreck-2', force = 'player', callback = ship_callback})
elseif math.random(25) == 1 then
table.insert(entities, {name = 'big-ship-wreck-3', force = 'player', callback = ship_callback})
end
end
@ -429,160 +142,104 @@ function run_borg(params)
tile_to_insert = 'stone-path'
end
if noise_borg_defense > 0.65 and noise_borg_defense < 0.66 then
if surface.can_place_entity {name = 'substation', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'substation', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'substation', force = 'enemy'})
end
if noise_borg_defense >= 0.54 and noise_borg_defense < 0.65 then
if surface.can_place_entity {name = 'solar-panel', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'solar-panel', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'solar-panel', force = 'enemy'})
end
if noise_borg_defense > 0.53 and noise_borg_defense < 0.54 then
if surface.can_place_entity {name = 'substation', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'substation', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'substation', force = 'enemy'})
end
if noise_borg_defense >= 0.51 and noise_borg_defense < 0.53 then
if surface.can_place_entity {name = 'accumulator', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'accumulator', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'accumulator', force = 'enemy'})
end
if noise_borg_defense >= 0.50 and noise_borg_defense < 0.51 then
if surface.can_place_entity {name = 'substation', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'substation', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'substation', force = 'enemy'})
end
if noise_borg_defense >= 0.487 and noise_borg_defense < 0.50 then
if surface.can_place_entity {name = 'laser-turret', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'laser-turret', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'laser-turret', force = 'enemy'})
end
if noise_borg_defense >= 0.485 and noise_borg_defense < 0.487 then
if surface.can_place_entity {name = 'substation', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'substation', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'substation', force = 'enemy'})
end
if noise_borg_defense >= 0.45 and noise_borg_defense < 0.484 then
if surface.can_place_entity {name = 'stone-wall', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'stone-wall', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'stone-wall', force = 'enemy'})
end
if noise_trees > 0.2 and tile_to_insert == 'sand-3' then
if math.random(1, 15) == 1 then
if math.random(1, 5) == 1 then
if surface.can_place_entity {name = 'dry-hairy-tree', position = {pos_x, pos_y}} then
surface.create_entity {name = 'dry-hairy-tree', position = {pos_x, pos_y}}
end
table.insert(entities, {name = 'dry-hairy-tree'})
else
if surface.can_place_entity {name = 'dry-tree', position = {pos_x, pos_y}} then
surface.create_entity {name = 'dry-tree', position = {pos_x, pos_y}}
end
end
end
end
local entity_list = {}
table.insert(entity_list, {name = 'big-ship-wreck-1', pos = {pos_x, pos_y}, chance = 35000, health = 'random'})
table.insert(entity_list, {name = 'big-ship-wreck-2', pos = {pos_x, pos_y}, chance = 45000, health = 'random'})
table.insert(entity_list, {name = 'big-ship-wreck-3', pos = {pos_x, pos_y}, chance = 55000, health = 'random'})
if noise_walls > -0.03 and noise_walls < 0.03 then
table.insert(entity_list, {name = 'gun-turret', pos = {pos_x, pos_y}, force = 'enemy', chance = 40})
end
if noise_borg_defense > 0.41 and noise_borg_defense < 0.45 then
table.insert(entity_list, {name = 'gun-turret', pos = {pos_x, pos_y}, force = 'enemy', chance = 15})
end
table.insert(entity_list, {name = 'pipe-to-ground', pos = {pos_x, pos_y}, force = 'enemy', chance = 7500})
if tile_to_insert ~= 'stone-path' and tile_to_insert ~= 'concrete' then
table.insert(
entity_list,
{name = 'dead-dry-hairy-tree', pos = {pos_x, pos_y}, force = 'enemy', chance = 1500}
)
table.insert(entity_list, {name = 'dead-grey-trunk', pos = {pos_x, pos_y}, force = 'enemy', chance = 1500})
end
table.insert(entity_list, {name = 'medium-ship-wreck', pos = {pos_x, pos_y}, chance = 25000, health = 'medium'})
table.insert(entity_list, {name = 'small-ship-wreck', pos = {pos_x, pos_y}, chance = 15000, health = 'medium'})
table.insert(entity_list, {name = 'car', pos = {pos_x, pos_y}, chance = 150000, health = 'low'})
table.insert(
entity_list,
{name = 'laser-turret', pos = {pos_x, pos_y}, chance = 100000, force = 'enemy', health = 'low'}
)
table.insert(
entity_list,
{name = 'nuclear-reactor', pos = {pos_x, pos_y}, chance = 1000000, force = 'enemy', health = 'medium'}
)
local b, placed_entity = place_entities(surface, entity_list)
if b == true then
if
placed_entity.name == 'big-ship-wreck-1' or placed_entity.name == 'big-ship-wreck-2' or
placed_entity.name == 'big-ship-wreck-3'
then
placed_entity.insert(wreck_item_pool[math.random(1, #wreck_item_pool)])
placed_entity.insert(wreck_item_pool[math.random(1, #wreck_item_pool)])
placed_entity.insert(wreck_item_pool[math.random(1, #wreck_item_pool)])
end
if placed_entity.name == 'gun-turret' then
if math.random(1, 3) == 1 then
placed_entity.insert('piercing-rounds-magazine')
else
placed_entity.insert('firearm-magazine')
table.insert(entities, {name = 'dry-tree'})
end
end
end
if noise_trees < -0.5 then
if tile_to_insert == 'sand-3' or tile_to_insert == 'sand-1' then
if math.random(1, 15) == 1 then
if surface.can_place_entity {name = 'rock-big', position = {pos_x, pos_y}} then
surface.create_entity {name = 'rock-big', position = {pos_x, pos_y}}
end
end
end
if math.random(35000) == 1 then
table.insert(entities, {name = 'big-ship-wreck-1', force = 'player', callback = ship_callback})
elseif math.random(45000) == 1 then
table.insert(entities, {name = 'big-ship-wreck-2', force = 'player', callback = ship_callback})
elseif math.random(55000) == 1 then
table.insert(entities, {name = 'big-ship-wreck-3', force = 'player', callback = ship_callback})
elseif noise_walls > -0.03 and noise_walls < 0.03 and math.random(40) == 1 then
table.insert(entities, {name = 'gun-turret', force = 'enemy', callback = turrent_callback})
elseif noise_borg_defense > 0.41 and noise_borg_defense < 0.45 and math.random(15) == 1 then
table.insert(entities, {name = 'gun-turret', force = 'enemy', callback = turrent_callback})
elseif math.random(7500) == 1 then
table.insert(entities, {name = 'pipe-to-ground', force = 'enemy'})
elseif tile_to_insert ~= 'stone-path' and tile_to_insert ~= 'concrete' and math.random(1500) == 1 then
table.insert(entities, {name = 'dead-dry-hairy-tree'})
elseif tile_to_insert ~= 'stone-path' and tile_to_insert ~= 'concrete' and math.random(1500) == 1 then
table.insert(entities, {name = 'dead-grey-trunk'})
elseif math.random(25000) == 1 then
table.insert(entities, {name = 'medium-ship-wreck', force = 'player', callback = medium_health})
elseif math.random(15000) == 1 then
table.insert(entities, {name = 'small-ship-wreck', force = 'player', callback = medium_health})
elseif math.random(150000) == 1 then
table.insert(entities, {name = 'car', force = 'player', callback = low_health})
elseif math.random(100000) == 1 then
table.insert(entities, {name = 'laser-turret', force = 'enemy', callback = low_health})
elseif math.random(1000000) == 1 then
table.insert(entities, {name = 'nuclear-reactor', force = 'enemy', callback = medium_health})
end
local noise_water_1 = perlin:noise(((pos_x + seed) / 200), ((pos_y + seed) / 200), 0)
if noise_trees < -0.5 and (tile_to_insert == 'sand-3' or tile_to_insert == 'sand-1') and math.random(15) == 1 then
table.insert(entities, {name = 'rock-big'})
end
local noise_water_1 = perlin:noise(((world.x + seed) / 200), ((world.y + seed) / 200), 0)
seed = seed + seed_increment_number
local noise_water_2 = perlin:noise(((pos_x + seed) / 100), ((pos_y + seed) / 100), 0)
local noise_water_2 = perlin:noise(((world.x + seed) / 100), ((world.y + seed) / 100), 0)
seed = seed + seed_increment_number
local noise_water_3 = perlin:noise(((pos_x + seed) / 25), ((pos_y + seed) / 25), 0)
local noise_water_3 = perlin:noise(((world.x + seed) / 25), ((world.y + seed) / 25), 0)
seed = seed + seed_increment_number
local noise_water_4 = perlin:noise(((pos_x + seed) / 10), ((pos_y + seed) / 10), 0)
local noise_water_4 = perlin:noise(((world.x + seed) / 10), ((world.y + seed) / 10), 0)
seed = seed + seed_increment_number
local noise_water = noise_water_1 + noise_water_2 + noise_water_3 * 0.07 + noise_water_4 * 0.07
local noise_water_1 = perlin:noise(((pos_x + seed) / 200), ((pos_y + seed) / 200), 0)
noise_water_1 = perlin:noise(((world.x + seed) / 200), ((world.y + seed) / 200), 0)
seed = seed + seed_increment_number
local noise_water_2 = perlin:noise(((pos_x + seed) / 100), ((pos_y + seed) / 100), 0)
noise_water_2 = perlin:noise(((world.x + seed) / 100), ((world.y + seed) / 100), 0)
seed = seed + seed_increment_number
local noise_water_3 = perlin:noise(((pos_x + seed) / 25), ((pos_y + seed) / 25), 0)
noise_water_3 = perlin:noise(((world.x + seed) / 25), ((world.y + seed) / 25), 0)
seed = seed + seed_increment_number
local noise_water_4 = perlin:noise(((pos_x + seed) / 10), ((pos_y + seed) / 10), 0)
noise_water_4 = perlin:noise(((world.x + seed) / 10), ((world.y + seed) / 10), 0)
seed = seed + seed_increment_number
local noise_water_2 = noise_water_1 + noise_water_2 + noise_water_3 * 0.07 + noise_water_4 * 0.07
noise_water_2 = noise_water_1 + noise_water_2 + noise_water_3 * 0.07 + noise_water_4 * 0.07
if tile_to_insert ~= 'stone-path' and tile_to_insert ~= 'concrete' then
if noise_water > -0.15 and noise_water < 0.15 and noise_water_2 > 0.5 then
if
tile_to_insert ~= 'stone-path' and tile_to_insert ~= 'concrete' and noise_water > -0.15 and noise_water < 0.15 and
noise_water_2 > 0.5
then
tile_to_insert = 'water-green'
local a = pos_x + 1
table.insert(tiles, {name = tile_to_insert, position = {a, pos_y}})
local a = pos_y + 1
table.insert(tiles, {name = tile_to_insert, position = {pos_x, a}})
local a = pos_x - 1
table.insert(tiles, {name = tile_to_insert, position = {a, pos_y}})
local a = pos_y - 1
table.insert(tiles, {name = tile_to_insert, position = {pos_x, a}})
table.insert(tiles, {name = tile_to_insert, position = {pos_x, pos_y}})
end
end
if noise_borg_defense <= 0.45 and tile_to_insert ~= 'water-green' then
local a = -0.01
local b = 0.01
if noise_walls > a and noise_walls < b then
if surface.can_place_entity {name = 'stone-wall', position = {pos_x, pos_y}, force = 'enemy'} then
surface.create_entity {name = 'stone-wall', position = {pos_x, pos_y}, force = 'enemy'}
end
table.insert(entities, {name = 'stone-wall', force = 'enemy'})
end
if noise_walls >= a and noise_walls <= b then
tile_to_insert = 'concrete'
@ -597,24 +254,20 @@ function run_borg(params)
end
end
local noise_decoratives_1 = perlin:noise(((pos_x + seed) / 50), ((pos_y + seed) / 50), 0)
seed = seed + seed_increment_number
local noise_decoratives_2 = perlin:noise(((pos_x + seed) / 15), ((pos_y + seed) / 15), 0)
local noise_decoratives_1 = perlin:noise(((world.x + seed) / 50), ((world.y + seed) / 50), 0)
seed = seed + seed_increment_number
local noise_decoratives_2 = perlin:noise(((world.x + seed) / 15), ((world.y + seed) / 15), 0)
local noise_decoratives = noise_decoratives_1 + noise_decoratives_2 * 0.3
local decoratives
if noise_decoratives > 0.3 and noise_decoratives < 0.5 then
if tile_to_insert ~= 'stone-path' and tile_to_insert ~= 'concrete' and tile_to_insert ~= 'water-green' then
if math.random(1, 10) == 1 then
table.insert(decoratives, {name = 'red-desert-bush', position = {pos_x, pos_y}, amount = 1})
if
tile_to_insert ~= 'stone-path' and tile_to_insert ~= 'concrete' and tile_to_insert ~= 'water-green' and
math.random(10) == 1
then
decoratives = {name = 'red-desert-bush', amount = 1}
end
end
end
table.insert(tiles, {name = tile_to_insert, position = {pos_x, pos_y}})
end
surface.set_tiles(tiles, true)
for _, deco in pairs(decoratives) do
surface.create_decoratives {check_collision = false, decoratives = {deco}}
end
return {tile = tile_to_insert, entities = entities, decoratives = decoratives}
end

14
map_gen/combined/island_resort.lua
View File

@ -4,9 +4,23 @@ local perlin = require 'map_gen.shared.perlin_noise'
local radius = 129
local radsquare = radius * radius
local clear_types = {'simple-entity', 'resource', 'tree'}
local function do_clear_entities(world)
local entities = world.surface.find_entities_filtered({area = world.area, type = clear_types})
for _, entity in ipairs(entities) do
entity.destroy()
end
end
return function(x, y, world)
local surface = world.surface
if not world.island_resort_cleared then
world.island_resort_cleared = true
do_clear_entities(world)
end
local entities = {}
local decoratives = {}

97
map_gen/shared/generate.lua
View File

@ -3,8 +3,11 @@ local Token = require 'utils.global_token'
local Event = require 'utils.event'
local shape
local tiles_per_tick
local regen_decoratives
local total_calls
local function do_row(row, data)
local function do_tile(tile, pos)
if not tile then
@ -21,7 +24,7 @@ local function do_row(row, data)
for x = top_x, top_x + 31 do
data.x = x
local pos = {data.x, data.y}
local pos = {x, y}
-- local coords need to be 'centered' to allow for correct rotation and scaling.
local tile = shape(x + 0.5, y + 0.5, data)
@ -51,6 +54,44 @@ local function do_row(row, data)
end
end
local function do_tile(y, x, data)
local function do_tile_inner(tile, pos)
if not tile then
table.insert(data.tiles, {name = 'out-of-map', position = pos})
elseif type(tile) == 'string' then
table.insert(data.tiles, {name = tile, position = pos})
end
end
local pos = {x, y}
-- local coords need to be 'centered' to allow for correct rotation and scaling.
local tile = shape(x + 0.5, y + 0.5, data)
if type(tile) == 'table' then
do_tile_inner(tile.tile, pos)
local entities = tile.entities
if entities then
for _, entity in ipairs(entities) do
if not entity.position then
entity.position = pos
end
table.insert(data.entities, entity)
end
end
local decoratives = tile.decoratives
if decoratives then
for _, decorative in ipairs(decoratives) do
table.insert(data.decoratives, decorative)
end
end
else
do_tile_inner(tile, pos)
end
end
local function do_place_tiles(data)
data.surface.set_tiles(data.tiles, true)
end
@ -79,7 +120,7 @@ local function do_place_decoratives(data)
end
local dec = data.decoratives
if dec then
if #dec > 0 then
data.surface.create_decoratives({check_collision = true, decoratives = dec})
end
end
@ -112,23 +153,49 @@ local function run_chart_update(data)
end
end
function map_gen_action(data)
local state = data.state
local function map_gen_action(data)
local state = data.y
if state < 32 then
do_row(state, data)
data.state = state + 1
local count = tiles_per_tick
local y = state + data.top_y
local x = data.x
local max_x = data.top_x + 32
data.y = y
repeat
count = count - 1
do_tile(y, x, data)
x = x + 1
if x == max_x then
y = y + 1
if y == data.top_y + 32 then
break
end
x = data.top_x
data.y = y
end
data.x = x
until count == 0
data.y = y - data.top_y
return true
elseif state == 32 then
do_place_tiles(data)
data.state = 33
data.y = 33
return true
elseif state == 33 then
do_place_entities(data)
data.state = 34
data.y = 34
return true
elseif state == 34 then
do_place_decoratives(data)
data.state = 35
data.y = 35
return true
elseif state == 35 then
run_chart_update(data)
@ -136,11 +203,15 @@ function map_gen_action(data)
end
end
local map_gen_action_token = Token.register(map_gen_action)
local function on_chunk(event)
local area = event.area
local data = {
state = 0,
y = 0,
x = area.left_top.x,
area = area,
top_x = area.left_top.x,
top_y = area.left_top.y,
surface = event.surface,
@ -148,13 +219,17 @@ local function on_chunk(event)
entities = {},
decoratives = {}
}
Task.queue_task('map_gen_action', data, 36)
Task.queue_task(map_gen_action_token, data, total_calls)
end
local function init(args)
shape = args.shape
tiles_per_tick = args.tiles_per_tick or 32
regen_decoratives = args.regen_decoratives or false
total_calls = math.ceil(1024 / tiles_per_tick) + 4
Event.add(defines.events.on_chunk_generated, on_chunk)
end

3
map_gen/shared/generate_not_threaded.lua
View File

@ -78,7 +78,7 @@ local function do_place_decoratives(data)
end
local dec = data.decoratives
if dec then
if #dec > 0 then
data.surface.create_decoratives({check_collision = true, decoratives = dec})
end
end
@ -100,6 +100,7 @@ local function on_chunk(event)
local area = event.area
local data = {
area = area,
top_x = area.left_top.x,
top_y = area.left_top.y,
surface = event.surface,

35
map_layout.lua
View File

@ -4,15 +4,17 @@ You may choose up to one of each type shapes, terrain, ores and misc or one of t
If you want to add your own module, just add it to the others
in this file and your run_*type*_module(event) function will be called.
--]]
local Event = require "utils.event"
local b = require "map_gen.shared.builders"
local b = require 'map_gen.shared.builders'
local shape = nil
local regen_decoratives = false
local tiles_per_tick = 32
--combined--
--shape = require "map_gen.combined.island_resort"
--require "map_gen.combined.red_planet_v2"
--require "map_gen.combined.borg_planet_v2"
--shape = require 'map_gen.combined.borg_planet_v2'
--require "map_gen.combined.dimensions"
--require "map_gen.combined.dagobah_swamp"
--require "map_gen.combined.meteor_strike" --unfinished
@ -84,7 +86,6 @@ local shape = nil
--ores--
--require "map_gen.ores.rso.rso_control"
-- modules that only return max one entity per tile
local entity_modules = {
--require "map_gen.ores.glitter_ores",
@ -97,7 +98,7 @@ local entity_modules = {
--require "map_gen.ores.resource_clustertruck"
}
local terrain_modules ={
local terrain_modules = {
--require "map_gen.misc.tris_chunk_grid",
}
@ -106,8 +107,6 @@ miscs = {}
--require "map_gen.misc.rusky_pvp"
--table.insert(miscs, require("map_gen.misc.rail_grid")) -- used for map_gen.presets.UK
local regen_decoratives = false
if #entity_modules > 0 then
shape = shape or b.full_shape
@ -123,26 +122,6 @@ if #terrain_modules > 0 then
end
if shape then
require ("map_gen.shared.generate")({shape = shape, regen_decoratives = regen_decoratives})
require('map_gen.shared.generate')({shape = shape, regen_decoratives = regen_decoratives, tiles_per_tick = tiles_per_tick})
--require ("map_gen.shared.generate_not_threaded")({shape = shape, regen_decoratives = regen_decoratives})
end
--[[ local on_chunk_generated = function(event)
if run_combined_module ~= nil then
run_combined_module(event)
end
if run_shape_module ~= nil then
run_shape_module(event)
end
if run_terrain_module ~= nil then
run_terrain_module(event)
end
if run_ores_module ~= nil then
run_ores_module(event)
end
for _,v in pairs(miscs) do
v.on_chunk_generated(event)
end
end
Event.add(defines.events.on_chunk_generated, on_chunk_generated) ]]

24
utils/Task.lua
View File

@ -4,9 +4,10 @@
-- github: https://github.com/Valansch/RedMew
-- ======================================================= --
local Queue = require "utils.Queue"
local PriorityQueue = require "utils.PriorityQueue"
local Event = require "utils.event"
local Queue = require 'utils.Queue'
local PriorityQueue = require 'utils.PriorityQueue'
local Event = require 'utils.event'
local Token = require 'utils.global_token'
local Task = {}
@ -25,7 +26,8 @@ local function on_tick()
for i = 1, get_task_per_tick() do
local task = Queue.peek(queue)
if task ~= nil then
local success, result = pcall(_G[task.func_name], task.params) -- result is error if not success else result is a boolean for if the task should stay in the queue.
-- result is error if not success else result is a boolean for if the task should stay in the queue.
local success, result = pcall(Token.get(task.func_token), task.params)
if not success then
log(result)
Queue.pop(queue)
@ -40,7 +42,7 @@ local function on_tick()
local callbacks = global.callbacks
local callback = PriorityQueue.peek(callbacks)
while callback ~= nil and game.tick >= callback.time do
local success, error = pcall(_G[callback.func_name], callback.params)
local success, error = pcall(Token.get(callback.func_token), callback.params)
if not success then
log(error)
end
@ -61,20 +63,20 @@ function get_task_per_tick()
return global.tpt
end
function Task.set_timeout_in_ticks(ticks, func_name, params)
function Task.set_timeout_in_ticks(ticks, func_token, params)
local time = game.tick + ticks
local callback = {time = time, func_name = func_name, params = params}
local callback = {time = time, func_token = func_token, params = params}
PriorityQueue.push(global.callbacks, callback, comp)
end
function Task.set_timeout(sec, func_name, params)
Task.set_timeout_in_ticks(60 * sec, func_name, params)
function Task.set_timeout(sec, func_token, params)
Task.set_timeout_in_ticks(60 * sec, func_token, params)
end
function Task.queue_task(func_name, params, weight)
function Task.queue_task(func_token, params, weight)
weight = weight or 1
global.total_task_weight = global.total_task_weight + weight
Queue.push(global.task_queue, {func_name = func_name, params = params, weight = weight})
Queue.push(global.task_queue, {func_token = func_token, params = params, weight = weight})
end
Event.add(defines.events.on_tick, on_tick)