1
0
mirror of https://github.com/Refactorio/RedMew.git synced 2024-12-16 10:19:27 +02:00
RedMew/map_gen/maps/crash_site/outpost_builder.lua
Jayefuu 75a8323fd0 Updated the starting pollution multiplier
The new meta sucks. No one builds any walls or defences. Players can go 3 or 4 hours with no attacks so long as they craft nothing.

Now that the pollution from outposts is generated at position = {0,0}.... let's try a very small amount of pollution for every outpost captured to force at least a small amount of defences to be built.

This will be MUCH less pollution than if all of the items they get free were made in base, but it will still force at least a few defenses or clearing of nearby bases.

Starting with a value of 10 to see how it goes.
2021-09-27 22:09:15 +01:00

1974 lines
52 KiB
Lua

--local Random = require 'map_gen.shared.random'
local Command = require 'utils.command'
local Ranks = require 'resources.ranks'
local Token = require 'utils.token'
local Global = require 'utils.global'
local Event = require 'utils.event'
local Task = require 'utils.task'
local Retailer = require 'features.retailer'
local Donator = require 'features.donator'
local RS = require 'map_gen.shared.redmew_surface'
local Server = require 'features.server'
local CrashSiteToast = require 'map_gen.maps.crash_site.crash_site_toast'
local table = require 'utils.table'
--local next = next
local pairs = pairs
local concat = table.concat
local floor = math.floor
local format = string.format
local tostring = tostring
local draw_text = rendering.draw_text
local render_mode_game = defines.render_mode.game
local b = require 'map_gen.shared.builders'
local direction_bit_mask = 0xc0000000
local section_bit_mask = 0x30000000
local level_bit_mask = 0x0fffffff
--local not_level_bit_mask = 0xf0000000
local direction_bit_shift = 30
local section_bit_shift = 28
--local section_straight = 0
--local section_outer_corner = 1
--local section_inner_corner = 2
local wall_north_straight = 0x00000001
local wall_east_straight = 0x40000001
local wall_south_straight = 0x80000001
local wall_west_straight = 0xc0000001
local wall_north_outer = 0x10000001
local wall_east_outer = 0x50000001
local wall_south_outer = 0x90000001
local wall_west_outer = 0xd0000001
local wall_north_inner = 0x20000001
local wall_east_inner = 0x60000001
local wall_south_inner = 0xa0000001
local wall_west_inner = 0xe0000001
local default_part_size = 6
local magic_crafters_per_tick = 3
local magic_fluid_crafters_per_tick = 8
local refill_turrets = {index = 1}
local power_sources = {}
local turret_to_outpost = {}
local magic_crafters = {index = 1}
local magic_fluid_crafters = {index = 1}
local outposts = {}
local artillery_outposts = {index = 1}
local outpost_count = 0
local base_pollution_multiplier = 10
local pollution_multiplier = {value = 10}
Global.register(
{
refil_turrets = refill_turrets,
power_sources = power_sources,
turret_to_outpost = turret_to_outpost,
magic_crafters = magic_crafters,
magic_fluid_crafters = magic_fluid_crafters,
outposts = outposts,
artillery_outposts = artillery_outposts,
pollution_multiplier = pollution_multiplier
},
function(tbl)
refill_turrets = tbl.refil_turrets
power_sources = tbl.power_sources
turret_to_outpost = tbl.turret_to_outpost
magic_crafters = tbl.magic_crafters
magic_fluid_crafters = tbl.magic_fluid_crafters
outposts = tbl.outposts
artillery_outposts = tbl.artillery_outposts
pollution_multiplier = tbl.pollution_multiplier
end
)
--[[ local function get_direction(part)
local dir = bit32.band(part, direction_bit_mask)
return bit32.rshift(dir, direction_bit_shift - 1)
end ]]
local function get_4_way_direction(part)
local dir = bit32.band(part, direction_bit_mask)
return bit32.rshift(dir, direction_bit_shift)
end
local function get_section(part)
local sec = bit32.band(part, section_bit_mask)
return bit32.rshift(sec, section_bit_shift)
end
local function get_level(part)
return bit32.band(part, level_bit_mask)
end
--[[ local function set_level(part, level)
local not_level = bit32.band(part)
return not_level + level
end
local function set_block(tbl, x, y, value)
tbl[(y - 1) * tbl.size + x] = value
end
local function get_block(tbl, x, y)
local size = tbl.size
if x < 1 or x > size or y < 1 or y > size then
return 0
end
return tbl[(y - 1) * size + x] or 0
end ]]
local function fast_remove(tbl, index)
local count = #tbl
if index > count then
return
elseif index < count then
tbl[index] = tbl[count]
end
tbl[count] = nil
end
local Public = {}
Public.__index = Public
Public.empty_template = {}
function Public.new(random)
local obj = {random = random}
return setmetatable(obj, Public)
end
local function do_walls(self, blocks, outpost_variance, outpost_min_step)
local size = blocks.size
local random = self.random
local max_variance = size - outpost_variance + 1
local variance_step = outpost_variance + outpost_min_step
local x = random:next_int(1, outpost_variance)
local y = random:next_int(1, outpost_variance)
local start_x, start_y = x, y
local i = (y - 1) * size + x
local pv = -1
-- top
while x < size do
local tx = x + random:next_int(outpost_min_step, variance_step)
tx = math.min(tx, size)
if pv == 0 then
blocks[i] = wall_north_straight
elseif pv == -1 then
blocks[i] = wall_north_outer
else
blocks[i] = wall_east_inner
end
x = x + 1
i = i + 1
while x < tx do
blocks[i] = wall_north_straight
x = x + 1
i = i + 1
end
if x < size - outpost_min_step then
local ty = random:next_int(1, outpost_variance)
if y == ty then
pv = 0
elseif y < ty then
pv = 1
blocks[i] = wall_east_outer
y = y + 1
i = i + size
while y < ty do
blocks[i] = wall_east_straight
y = y + 1
i = i + size
end
else
pv = -1
blocks[i] = wall_north_inner
y = y - 1
i = i - size
while y > ty do
blocks[i] = wall_west_straight
y = y - 1
i = i - size
end
end
else
pv = 0
end
end
pv = 1
-- right
while y < size do
local ty = y + random:next_int(outpost_min_step, variance_step)
ty = math.min(ty, size)
if pv == 0 then
blocks[i] = wall_east_straight
elseif pv == -1 then
blocks[i] = wall_south_inner
else
blocks[i] = wall_east_outer
end
y = y + 1
i = i + size
while y < ty do
blocks[i] = wall_east_straight
y = y + 1
i = i + size
end
if y < size - outpost_min_step then
local tx = random:next_int(max_variance, size)
if x == tx then
pv = 0
elseif x < tx then
pv = 1
blocks[i] = wall_east_inner
x = x + 1
i = i + 1
while x < tx do
blocks[i] = wall_north_straight
x = x + 1
i = i + 1
end
else
pv = -1
blocks[i] = wall_south_outer
x = x - 1
i = i - 1
while x > tx do
blocks[i] = wall_south_straight
x = x - 1
i = i - 1
end
end
else
pv = 0
end
end
pv = 1
-- bottom
while x > 1 do
local tx = x - random:next_int(outpost_min_step, variance_step)
tx = math.max(tx, 1)
if pv == 0 then
blocks[i] = wall_south_straight
elseif pv == -1 then
blocks[i] = wall_west_inner
else
blocks[i] = wall_south_outer
end
x = x - 1
i = i - 1
while x > tx do
blocks[i] = wall_south_straight
x = x - 1
i = i - 1
end
if x > outpost_min_step + 1 then
local ty = random:next_int(max_variance, size)
if y == ty then
pv = 0
elseif y < ty then
pv = 1
blocks[i] = wall_south_inner
y = y + 1
i = i + size
while y < ty do
blocks[i] = wall_east_straight
y = y + 1
i = i + size
end
else
pv = -1
blocks[i] = wall_west_outer
y = y - 1
i = i - size
while y > ty do
blocks[i] = wall_west_straight
y = y - 1
i = i - size
end
end
else
pv = 0
end
end
pv = -1
-- left
local bottom_left_y = y
while y > start_y + variance_step do
local ty = y - random:next_int(outpost_min_step, variance_step)
ty = math.max(ty, start_y)
if pv == 0 then
blocks[i] = wall_west_straight
elseif pv == -1 then
blocks[i] = wall_west_outer
else
blocks[i] = wall_north_inner
end
y = y - 1
i = i - size
while y > ty do
blocks[i] = wall_west_straight
y = y - 1
i = i - size
end
if y > start_y + variance_step + outpost_min_step then
local tx = random:next_int(1, outpost_variance)
if x == tx then
pv = 0
elseif x < tx then
pv = 1
--blocks[i] = wall_west_outer
blocks[i] = wall_north_outer
x = x + 1
i = i + 1
while x < tx do
blocks[i] = wall_north_straight
x = x + 1
i = i + 1
end
else
pv = -1
blocks[i] = wall_west_inner
x = x - 1
i = i - 1
while x > tx do
blocks[i] = wall_south_straight
x = x - 1
i = i - 1
end
end
else
pv = 0
end
end
-- final connection
if y == bottom_left_y then
blocks[i] = wall_west_outer
y = y - 1
i = i - size
while y > bottom_left_y - outpost_min_step do
blocks[i] = wall_west_straight
y = y - 1
i = i - size
end
end
if x == start_x then
pv = 0
elseif x < start_x then
pv = 1
blocks[i] = wall_north_outer
x = x + 1
i = i + 1
while x < start_x do
blocks[i] = wall_north_straight
x = x + 1
i = i + 1
end
else
pv = -1
blocks[i] = wall_west_inner
x = x - 1
i = i - 1
while x > start_x do
blocks[i] = wall_south_straight
x = x - 1
i = i - 1
end
end
if pv == 0 then
blocks[i] = wall_west_straight
elseif pv == -1 then
blocks[i] = wall_west_outer
else
blocks[i] = wall_north_inner
end
y = y - 1
i = i - size
while y > start_y do
blocks[i] = wall_west_straight
y = y - 1
i = i - size
end
end
local function fill(blocks)
local size = blocks.size
local anti_set = {size = size}
local anti_stack = {}
local y_offset = (size - 1) * size
for x = 1, size do
if blocks[x] == nil then
anti_stack[#anti_stack + 1] = {x = x, y = 1}
end
if blocks[x + y_offset] == nil then
anti_stack[#anti_stack + 1] = {x = x, y = size}
end
end
for y = 2, size do
y_offset = (y - 1) * size
if blocks[y_offset + 1] == nil then
anti_stack[#anti_stack + 1] = {x = 1, y = y}
end
if blocks[y_offset + size] == nil then
anti_stack[#anti_stack + 1] = {x = size, y = y}
end
end
while #anti_stack > 0 do
local point = table.remove(anti_stack)
local x, y = point.x, point.y
local offset = (y - 1) * size + x
anti_set[offset] = true
if x > 1 then
local x2 = x - 1
local offset2 = offset - 1
if not anti_set[offset2] and not blocks[offset2] then
anti_stack[#anti_stack + 1] = {x = x2, y = y}
end
end
if x < size then
local x2 = x + 1
local offset2 = offset + 1
if not anti_set[offset2] and not blocks[offset2] then
anti_stack[#anti_stack + 1] = {x = x2, y = y}
end
end
if y > 1 then
local y2 = y - 1
local offset2 = offset - size
if not anti_set[offset2] and not blocks[offset2] then
anti_stack[#anti_stack + 1] = {x = x, y = y2}
end
end
if y < size then
local y2 = y + 1
local offset2 = offset + size
if not anti_set[offset2] and not blocks[offset2] then
anti_stack[#anti_stack + 1] = {x = x, y = y2}
end
end
end
for y = 1, size do
local offset = (y - 1) * size
for x = 1, size do
local i = offset + x
if not anti_set[i] and not blocks[i] then
blocks[i] = 2
end
end
end
end
local function do_levels(blocks, max_level)
local size = blocks.size
local level = 2
while level < max_level do
local next_level = level + 1
for y = 1, size do
local offset = (y - 1) * size
for x = 1, size do
local i = offset + x
if get_level(blocks[i] or 0) >= level then
local count = 0
if x > 1 and get_level(blocks[i - 1] or 0) >= level then
count = count + 1
end
if x < size and get_level(blocks[i + 1] or 0) >= level then
count = count + 1
end
if y > 1 and get_level(blocks[i - size] or 0) >= level then
count = count + 1
end
if y < size and get_level(blocks[i + size] or 0) >= level then
count = count + 1
end
if count == 4 then
blocks[i] = next_level
end
end
end
end
level = level + 1
end
local levels = {}
blocks.levels = levels
for i = 1, max_level do
levels[i] = {}
end
for y = 1, size do
local offset = (y - 1) * size
for x = 1, size do
local i = offset + x
local block = blocks[i]
if block then
local l = get_level(block)
local lvl = levels[l]
lvl[#lvl + 1] = i
end
end
end
end
local function get_template(random, templates, templates_count, counts)
local template
if templates_count == 0 then
return nil
elseif templates_count == 1 then
template = templates[1]
else
local ti = random:next_int(1, templates_count)
template = templates[ti]
end
if template == Public.empty_template then
return nil
end
local count = counts[template] or 0
local max_count = template.max_count
while count == max_count do
template = template.fallback
if template == nil then
return nil
end
count = counts[template] or 0
max_count = template.max_count
end
counts[template] = count + 1
return template
end
local function make_blocks(self, blocks, template)
local random = self.random
local counts = {}
local levels = blocks.levels
local wall_level = levels[1]
local walls = template.walls
local wall_template_count = #walls
while #wall_level > 0 do
local index = random:next_int(1, #wall_level)
local i = wall_level[index]
fast_remove(wall_level, index)
local block = get_template(random, walls, wall_template_count, counts)
if block == Public.empty_template then
blocks[i] = nil
else
local block_data = blocks[i]
local section = get_section(block_data)
local dir = get_4_way_direction(block_data)
local new_block = block[section + 1][dir + 1]
blocks[i] = new_block
end
end
local bases = template.bases
for l = 2, #levels do
local level = levels[l]
local base_templates = bases[l - 1]
if base_templates then
local base_template_count = #base_templates
while #level > 0 do
local index = random:next_int(1, #level)
local i = level[index]
fast_remove(level, index)
blocks[i] = get_template(random, base_templates, base_template_count, counts)
end
else
for index = 1, #level do
local i = level[index]
blocks[i] = nil
end
end
end
end
local remove_entity_types = {'tree', 'simple-entity'}
local function to_shape(blocks, part_size, on_init)
part_size = part_size or default_part_size
local inv_part_size = 1 / part_size
local size = blocks.size
local t_size = size * part_size
local half_t_size = t_size * 0.5
local outpost_id = outpost_count + 1
outpost_count = outpost_id
if on_init then
outposts[outpost_id] = {
outpost_id = outpost_id,
magic_crafters = {},
--magic_fluid_crafters = {},
market = nil,
turret_count = 0,
top_left = {nil, nil},
bottom_right = {nil, nil},
level = 1,
upgrade_rate = nil,
upgrade_base_cost = nil,
upgrade_cost_base = nil,
artillery_area = nil,
artillery_turrets = nil,
last_fire_tick = nil
}
end
local function shape(x, y, world)
x, y = floor(x + half_t_size), floor(y + half_t_size)
if x < 0 or y < 0 or x >= t_size or y >= t_size then
return false
end
local x2, y2 = floor(x * inv_part_size), floor(y * inv_part_size)
local template = blocks[y2 * size + x2 + 1]
if not template then
return false
end
local wx, wy = world.x, world.y
local entities =
world.surface.find_entities_filtered {
area = {{wx, wy}, {wx + 1, wy + 1}},
type = remove_entity_types
}
for i = 1, #entities do
local e = entities[i]
e.destroy()
end
local x3, y3 = x - x2 * part_size, y - y2 * part_size
local i = y3 * part_size + x3 + 1
local entry = template[i]
if not entry then
return false
end
local entity = entry.entity
local tile = entry.tile or true
if entity then
local data
local callback = entity.callback
if callback then
data = {outpost_id = outpost_id}
local cd = template[callback]
callback = cd.callback
data.callback_data = cd.data
end
return {
tile = tile,
entities = {
{
name = entity.name,
direction = entity.direction,
force = entity.force or template.force,
callback = callback,
data = data,
always_place = true
}
}
}
end
return tile
end
return b.change_map_gen_collision_hidden_tile(shape, 'water-tile', 'grass-1')
end
Public.to_shape = to_shape
function Public:do_outpost(template, on_init)
local settings = template.settings
local blocks = {size = settings.blocks}
do_walls(self, blocks, settings.variance, settings.min_step)
fill(blocks)
do_levels(blocks, settings.max_level)
make_blocks(self, blocks, template)
return to_shape(blocks, settings.part_size, on_init)
end
local function change_direction(entity, new_dir)
local copy = {}
for k, v in pairs(entity) do
copy[k] = v
end
copy.direction = new_dir
return copy
end
function Public.make_1_way(data)
data.__index = data
return data
end
local function set_tile(tbl, index, tile)
local entry = tbl[index]
if entry then
entry.tile = tile
else
tbl[index] = {tile = tile}
end
end
local function set_entity(tbl, index, entity)
local entry = tbl[index]
if entry then
entry.entity = entity
else
tbl[index] = {entity = entity}
end
end
function Public.make_4_way(data)
local part_size = data.part_size or default_part_size
local inv_part_size = 1 / part_size
local props = {}
local north = {}
local east = {}
local south = {}
local west = {}
local res = {north, east, south, west}
for i, entry in pairs(data) do
if type(i) == 'string' then
props[i] = entry
else
local y = math.ceil(i * inv_part_size)
local x = i - (y - 1) * part_size
local x2 = part_size - y + 1
local y2 = x
local x3 = part_size - x + 1
local y3 = part_size - y + 1
local x4 = y
local y4 = part_size - x + 1
local i2 = (y2 - 1) * part_size + x2
local i3 = (y3 - 1) * part_size + x3
local i4 = (y4 - 1) * part_size + x4
local tile = entry.tile
if tile then
set_tile(north, i, tile)
set_tile(east, i2, tile)
set_tile(south, i3, tile)
set_tile(west, i4, tile)
end
local entity = entry.entity
if entity then
local offset = entity.offset
if offset == 3 then
i = i + part_size + 1
i2 = i2 + part_size
i4 = i4 + 1
elseif offset == 1 then
i = i + 1
i2 = i2 + part_size
elseif offset == 2 then
i = i + part_size
i4 = i4 + 1
end
local dir = entity.direction or 0
set_entity(north, i, entity)
set_entity(east, i2, change_direction(entity, (dir + 2) % 8))
set_entity(south, i3, change_direction(entity, (dir + 4) % 8))
set_entity(west, i4, change_direction(entity, (dir + 6) % 8))
end
end
end
north.__index = north
east.__index = east
south.__index = south
west.__index = west
for k, v in pairs(props) do
north[k] = v
east[k] = v
south[k] = v
west[k] = v
end
return res
end
function Public.make_walls(data)
data.__index = data
return data
end
local function shallow_copy(tbl)
local copy = {}
for k, v in pairs(tbl) do
copy[k] = v
end
return copy
end
function Public.extend_1_way(data, tbl)
return setmetatable(shallow_copy(tbl), data)
end
function Public.extend_4_way(data, tbl)
return {
setmetatable(shallow_copy(tbl), data[1]),
setmetatable(shallow_copy(tbl), data[2]),
setmetatable(shallow_copy(tbl), data[3]),
setmetatable(shallow_copy(tbl), data[4])
}
end
function Public.extend_walls(data, tbl)
local copy = shallow_copy(tbl)
local base = {
Public.extend_4_way(data[1], copy),
Public.extend_4_way(data[2], copy),
Public.extend_4_way(data[3], copy)
}
base.__index = base
return setmetatable(copy, base)
end
local function update_market_upgrade_description(outpost_data)
local outpost_id = outpost_data.outpost_id
local upgrade_rate = outpost_data.upgrade_rate
local upgrade_base_cost = outpost_data.upgrade_base_cost
local upgrade_cost_base = outpost_data.upgrade_cost_base
local level = outpost_data.level
local base_outputs = outpost_data.base_outputs
local outpost_magic_crafters = outpost_data.magic_crafters
local prototype = Retailer.get_items(outpost_id)['upgrade']
prototype.price = upgrade_base_cost * #outpost_magic_crafters * upgrade_cost_base ^ (level - 1)
prototype.name_label = 'Upgrade Outpost to level ' .. tostring(level + 1)
local tooltip_str = {''}
local mapview_str = {''}
local count = 2
for k, v in pairs(base_outputs) do
local base_rate = v * 60
local upgrade_per_level = base_rate * upgrade_rate
local current_rate = base_rate + (level - 1) * upgrade_per_level
local next_rate = current_rate + upgrade_per_level
local name = game.item_prototypes[k]
if name then
tooltip_str[count] = concat {'[item=', k, ']'}
mapview_str[count] = name.localised_name
else
name = game.fluid_prototypes[k]
if name then
tooltip_str[count] = concat {'[fluid=', k, ']'}
mapview_str[count] = name.localised_name
else
tooltip_str[count] = k
mapview_str[count] = k
end
end
count = count + 1
local str = concat {': ', format('%.2f', current_rate), ' -> ', format('%.2f / sec', next_rate)}
tooltip_str[count] = str
tooltip_str[count + 1] = '\n'
mapview_str[count] = str
mapview_str[count + 1] = ', '
count = count + 2
end
tooltip_str[count - 1] = nil
mapview_str[count - 1] = nil
prototype.description = tooltip_str
prototype.disabled = false
prototype.mapview_description = mapview_str
Retailer.set_item(outpost_id, prototype)
end
local function do_outpost_upgrade(event)
if event.item.type ~= 'upgrade' then
return
end
local outpost_id = event.group_name
local outpost_data = outposts[outpost_id]
local outpost_magic_crafters = outpost_data.magic_crafters
local upgrade_rate = outpost_data.upgrade_rate
local level = outpost_data.level + 1
outpost_data.level = level
local player_name = event.player.name
local outpost_name = Retailer.get_market_group_label(outpost_id)
local message = concat {player_name, ' has upgraded ', outpost_name, ' to level ', level}
CrashSiteToast.do_outpost_toast(outpost_data.market, message)
Server.to_discord_bold(concat {'*** ', message, ' ***'})
for i = 1, #outpost_magic_crafters do
local crafter = outpost_magic_crafters[i]
local rate = crafter.rate
local upgrade_amount = upgrade_rate * crafter.base_rate
crafter.rate = rate + upgrade_amount
end
update_market_upgrade_description(outpost_data)
end
local function activate_market_upgrade(outpost_data)
local outpost_magic_crafters = outpost_data.magic_crafters
if #outpost_magic_crafters == 0 then
local outpost_id = outpost_data.outpost_id
local prototype = Retailer.get_items(outpost_id)['upgrade']
prototype.disabled_reason = 'No machines to upgrade.'
Retailer.set_item(outpost_id, prototype)
return
end
local base_outputs = {}
for i = 1, #outpost_magic_crafters do
local crafter = outpost_magic_crafters[i]
local item = crafter.item
local count = base_outputs[item] or 0
count = count + crafter.rate
base_outputs[item] = count
end
outpost_data.base_outputs = base_outputs
update_market_upgrade_description(outpost_data)
end
function Public.activate_market_upgrade(outpost_id)
local outpost_data = outposts[outpost_id]
activate_market_upgrade(outpost_data)
end
local function do_capture_outpost(outpost_data)
local area = {top_left = outpost_data.top_left, bottom_right = outpost_data.bottom_right}
local walls = RS.get_surface().find_entities_filtered {area = area, force = 'enemy', name = 'stone-wall'}
for i = 1, #walls do
walls[i].force = 'player'
end
local outpost_id = outpost_data.outpost_id
local name = Retailer.get_market_group_label(outpost_id)
if name == 'Market' then
return
end
local donators = Donator.get_donators_table()
if next(donators) then
local donator = table.get_random_dictionary_entry(donators, true)
if donator then
name = concat({donator, "'s ", name})
Retailer.set_market_group_label(outpost_id, name)
end
end
local message = 'Outpost captured: ' .. name
CrashSiteToast.do_outpost_toast(outpost_data.market, message)
Server.to_discord_bold(concat {'*** ', message, ' ***'})
activate_market_upgrade(outpost_data)
end
local function do_refill_turrets()
local index = refill_turrets.index
if index > #refill_turrets then
refill_turrets.index = 1
return
end
local turret_data = refill_turrets[index]
local turret = turret_data.turret
if not turret.valid then
fast_remove(refill_turrets, index)
return
end
refill_turrets.index = index + 1
local data = turret_data.data
if data.liquid then
turret.fluidbox[1] = data
elseif data then
turret.insert(data)
end
end
local artillery_target_entities = {
'character',
'tank',
'car',
'locomotive',
'cargo-wagon',
'fluid-wagon',
'artillery-wagon',
'spidertron'
}
local artillery_target_callback =
Token.register(
function(data)
local position = data.position
local entity = data.entity
if not entity.valid then
return
end
local tx, ty = position.x, position.y
local pos = entity.position
local x, y = pos.x, pos.y
local dx, dy = tx - x, ty - y
local d = dx * dx + dy * dy
if d >= 1024 then -- 32 ^ 2
entity.surface.create_entity {
name = 'artillery-projectile',
position = position,
target = entity,
speed = 1.5
}
if entity.name == "spidertron" then
-- fire a rocket as well as artillery-projectile since artillery-projectile doesn't damage spidertrons
-- Balance note: 1 rocket per artillery kills spidertron shield fast but takes ~ 1 minute to kill the spidertron
entity.surface.create_entity {
name = 'rocket',
position = position,
target = entity,
speed = 1.5
}
end
end
end
)
local function do_artillery_turrets_targets()
local index = artillery_outposts.index
if index > #artillery_outposts then
artillery_outposts.index = 1
return
end
artillery_outposts.index = index + 1
local outpost = artillery_outposts[index]
local now = game.tick
if now - outpost.last_fire_tick < 480 then
return
end
local turrets = outpost.artillery_turrets
for i = #turrets, 1, -1 do
local turret = turrets[i]
if not turret.valid then
fast_remove(turrets, i)
end
end
local count = #turrets
if count == 0 then
fast_remove(artillery_outposts, index)
return
end
outpost.last_fire_tick = now
local turret = turrets[1]
local area = outpost.artillery_area
local surface = turret.surface
local entities = surface.find_entities_filtered {area = area, name = artillery_target_entities}
if #entities == 0 then
return
end
local position = turret.position
for i = 1, count do
local entity = entities[math.random(#entities)]
if entity and entity.valid then
local data = {position = position, entity = entity}
Task.set_timeout_in_ticks(i * 60, artillery_target_callback, data)
end
end
end
local server_player = {name = '<server>', print = print}
local function set_pollution_multiplier(args, player)
local multiplier = tonumber(args.multiplier)
player = player or server_player
if not multiplier then
player.print("Fail")
return
end
if multiplier < base_pollution_multiplier then
pollution_multiplier.value = base_pollution_multiplier
player.print("Cannot set the multiplier lower than the base multiplier of " .. base_pollution_multiplier)
end
local old_multiplier = pollution_multiplier.value
pollution_multiplier.value = multiplier
local message = player.name..' changed magic crafter pollution multiplier from '..old_multiplier..' to '..pollution_multiplier.value
for _, p in pairs(game.players) do
if p.admin then
p.print(message)
end
end
end
local function get_pollution_multiplier(_, player)
player = player or server_player
player.print('Current pollution multiplier is: '..pollution_multiplier.value)
end
local function do_magic_crafters()
local limit = #magic_crafters
if limit == 0 then
return
end
local index = magic_crafters.index
for i = 1, magic_crafters_per_tick do
if index > limit then
index = 1
end
local data = magic_crafters[index]
local entity = data.entity
if not entity.valid then
fast_remove(magic_crafters, index)
limit = limit - 1
if limit == 0 then
return
end
else
index = index + 1
local tick = game.tick
local last_tick = data.last_tick
local rate = data.rate
local count = (tick - last_tick) * rate
local fcount = floor(count)
if fcount > 0 then
local output_inv = entity.get_output_inventory()
if output_inv.can_insert(data.item) then -- No pollution if full. Taking items out of crafters makes pollution
local pollution_amount = pollution_multiplier.value * 0.01
local pollution_position = {0,0}
entity.surface.pollute(pollution_position, pollution_amount)
output_inv.insert {name = data.item, count = fcount}
end
data.last_tick = tick - (count - fcount) / rate
end
end
end
magic_crafters.index = index
end
local function do_magic_fluid_crafters()
local limit = #magic_fluid_crafters
if limit == 0 then
return
end
local index = magic_fluid_crafters.index
for i = 1, magic_fluid_crafters_per_tick do
if index > limit then
index = 1
end
local data = magic_fluid_crafters[index]
local entity = data.entity
if not entity.valid then
fast_remove(magic_fluid_crafters, index)
limit = limit - 1
if limit == 0 then
return
end
else
index = index + 1
local tick = game.tick
local last_tick = data.last_tick
local rate = data.rate
local count = (tick - last_tick) * rate
local fcount = floor(count)
if fcount > 0 then
local fluidbox_index = data.fluidbox_index
local fb = entity.fluidbox
local fb_data = fb[fluidbox_index] or {name = data.item, amount = 0}
fb_data.amount = fb_data.amount + fcount
fb[fluidbox_index] = fb_data
data.last_tick = tick - (count - fcount) / rate
end
end
end
magic_fluid_crafters.index = index
end
local function tick()
do_refill_turrets()
do_artillery_turrets_targets()
do_magic_crafters()
do_magic_fluid_crafters()
end
Public.refill_turret_callback =
Token.register(
function(turret, data)
local outpost_id = data.outpost_id
refill_turrets[#refill_turrets + 1] = {turret = turret, data = data.callback_data}
turret_to_outpost[turret.unit_number] = outpost_id
local outpost_data = outposts[outpost_id]
outpost_data.turret_count = outpost_data.turret_count + 1
end
)
Public.refill_liquid_turret_callback =
Token.register(
function(turret, data)
local callback_data = data.callback_data
callback_data.liquid = true
local outpost_id = data.outpost_id
refill_turrets[#refill_turrets + 1] = {turret = turret, data = callback_data}
turret_to_outpost[turret.unit_number] = outpost_id
local outpost_data = outposts[outpost_id]
outpost_data.turret_count = outpost_data.turret_count + 1
end
)
Public.refill_artillery_turret_callback =
Token.register(
function(turret, data)
local outpost_id = data.outpost_id
refill_turrets[#refill_turrets + 1] = {turret = turret, data = data.callback_data}
turret_to_outpost[turret.unit_number] = outpost_id
local outpost_data = outposts[outpost_id]
outpost_data.turret_count = outpost_data.turret_count + 1
local artillery_turrets = outpost_data.artillery_turrets
if not artillery_turrets then
artillery_turrets = {}
outpost_data.artillery_turrets = artillery_turrets
local pos = turret.position
local x, y = pos.x, pos.y
outpost_data.artillery_area = {{x - 112, y - 112}, {x + 112, y + 112}}
outpost_data.last_fire_tick = 0
artillery_outposts[#artillery_outposts + 1] = outpost_data
end
artillery_turrets[#artillery_turrets + 1] = turret
end
)
Public.power_source_callback =
Token.register(
function(turret, data)
local outpost_id = data.outpost_id
local callback_data = data.callback_data
local power_source =
turret.surface.create_entity {name = 'hidden-electric-energy-interface', position = turret.position}
power_source.electric_buffer_size = callback_data.buffer_size
power_source.power_production = callback_data.power_production
power_source.destructible = false
power_sources[turret.unit_number] = {entity = power_source}
turret_to_outpost[turret.unit_number] = outpost_id
local outpost_data = outposts[outpost_id]
outpost_data.turret_count = outpost_data.turret_count + 1
end
)
Public.worm_turret_callback =
Token.register(
function(turret, data)
local outpost_id = data.outpost_id
turret_to_outpost[turret.unit_number] = outpost_id
local outpost_data = outposts[outpost_id]
outpost_data.turret_count = outpost_data.turret_count + 1
end
)
local function add_magic_crafter_output(entity, output, distance, outpost_id)
local rate = output.min_rate + output.distance_factor * distance
local fluidbox_index = output.fluidbox_index
local data = {
entity = entity,
last_tick = game.tick,
base_rate = rate,
rate = rate,
item = output.item,
fluidbox_index = fluidbox_index
}
if fluidbox_index then
magic_fluid_crafters[#magic_fluid_crafters + 1] = data
else
magic_crafters[#magic_crafters + 1] = data
end
local outpost_magic_crafters = outposts[outpost_id].magic_crafters
outpost_magic_crafters[#outpost_magic_crafters + 1] = data
end
local set_inactive_token =
Token.register(
function(entity)
if entity.valid then
entity.active = false
end
end
)
local change_to_player_force_callback = Token.register(function(entity)
if entity.valid then
entity.force = 'player'
end
end)
Public.magic_item_crafting_callback =
Token.register(
function(entity, data)
local outpost_id = data.outpost_id
local callback_data = data.callback_data
entity.minable = false
entity.destructible = false
entity.operable = false
-- This is so the recipe is set for furnaces even if the player force hasn't unlocked them yet.
entity.force = 'neutral'
Task.set_timeout_in_ticks(1, change_to_player_force_callback, entity)
local recipe = callback_data.recipe
if recipe then
entity.set_recipe(recipe)
if not callback_data.has_fluid_output then -- to avoid trying to put an item into a fluid inventory
entity.get_output_inventory().insert(callback_data.output.item)
end
else
local furnace_item = callback_data.furnace_item
if furnace_item then
local inv = entity.get_inventory(2) -- defines.inventory.furnace_source
inv.insert(furnace_item)
entity.get_output_inventory().insert(callback_data.output.item)
end
end
local p = entity.position
local x, y = p.x, p.y
local distance = math.sqrt(x * x + y * y)
local output = callback_data.output
if #output == 0 then
add_magic_crafter_output(entity, output, distance, outpost_id)
else
for i = 1, #output do
local o = output[i]
add_magic_crafter_output(entity, o, distance, outpost_id)
end
end
if not callback_data.has_fluid_output then
Task.set_timeout_in_ticks(2, set_inactive_token, entity) -- causes problems with refineries.
end
end
)
Public.magic_item_crafting_callback_weighted =
Token.register(
function(entity, data)
local outpost_id = data.outpost_id
local callback_data = data.callback_data
entity.minable = false
entity.destructible = false
entity.operable = false
-- This is so the recipe is set for furnaces even if the player force hasn't unlocked them yet.
entity.force = 'neutral'
Task.set_timeout_in_ticks(1, change_to_player_force_callback, entity)
local weights = callback_data.weights
local loot = callback_data.loot
local i = math.random() * weights.total
local index = table.binary_search(weights, i)
if (index < 0) then
index = bit32.bnot(index)
end
local stack = loot[index].stack
if not stack then
return
end
local recipe = stack.recipe
if recipe then
entity.set_recipe(recipe)
local output_inv = entity.get_output_inventory()
output_inv.insert {name = stack.output.item, count = 200}
else
local furnace_item = stack.furnace_item
if furnace_item then
local inv = entity.get_inventory(2) -- defines.inventory.furnace_source
inv.insert {name = furnace_item, count = 200}
local output_inv = entity.get_output_inventory()
output_inv.insert {name = stack.output.item, count = 200 }
end
end
local p = entity.position
local x, y = p.x, p.y
local distance = math.sqrt(x * x + y * y)
local output = stack.output
if #output == 0 then
add_magic_crafter_output(entity, output, distance, outpost_id)
else
for o_i = 1, #output do
local o = output[o_i]
add_magic_crafter_output(entity, o, distance, outpost_id)
end
end
if not callback_data.has_fluid_output then
Task.set_timeout_in_ticks(2, set_inactive_token, entity) -- causes problems with refineries.
end
end
)
Public.wall_callback =
Token.register(
function(entity, data)
if not entity.valid then
return
end
local position = entity.position
local px, py = position.x, position.y
local outpost_id = data.outpost_id
local outpost_data = outposts[outpost_id]
local top_left = outpost_data.top_left
local bottom_right = outpost_data.bottom_right
local tx, ty = top_left.x, top_left.y
local bx, by = bottom_right.x, bottom_right.y
if not tx or px < tx then
top_left.x = px
end
if not ty or py < ty then
top_left.y = py
end
if not bx or px > bx then
bottom_right.x = px
end
if not by or py > by then
bottom_right.y = py
end
end
)
Public.deactivate_callback =
Token.register(
function(entity)
entity.active = false
entity.operable = false
entity.destructible = false
end
)
Public.scenario_chest_callback = Token.register(function(chest)
if not chest or not chest.valid then
return
end
chest.destructible = false
chest.minable = false
end)
local function turret_died(event)
local entity = event.entity
if not entity or not entity.valid then
return
end
local number = entity.unit_number
if not number then
return
end
local ps_data = power_sources[number]
if ps_data then
power_sources[number] = nil
local ps_entity = ps_data.entity
if ps_entity and ps_entity.valid then
ps_entity.destroy()
end
end
local outpost_id = turret_to_outpost[number]
if outpost_id then
local outpost_data = outposts[outpost_id]
local turret_count = outpost_data.turret_count - 1
outpost_data.turret_count = turret_count
if turret_count == 0 then
do_capture_outpost(outpost_data)
end
end
end
Public.market_set_items_callback =
Token.register(
function(entity, data)
if not entity.valid then
return
end
local callback_data = data.callback_data
entity.destructible = false
local market_id = data.outpost_id
local outpost_data = outposts[market_id]
local upgrade_base_cost = callback_data.upgrade_base_cost or 0
outpost_data.market = entity
outpost_data.upgrade_rate = callback_data.upgrade_rate
outpost_data.upgrade_base_cost = upgrade_base_cost
outpost_data.upgrade_cost_base = callback_data.upgrade_cost_base
Retailer.add_market(market_id, entity)
Retailer.set_market_group_label(market_id, callback_data.market_name)
Retailer.set_item(
market_id,
{
name = 'upgrade',
type = 'upgrade',
name_label = 'Upgrade Outpost',
sprite = 'item-group/production',
price = 0,
stack_limit = 1,
disabled = true,
disabled_reason = 'Outpost must be captured first.',
description = 'Increases output.'
}
)
local p = entity.position
local x, y = p.x, p.y
local d = math.sqrt(x * x + y * y)
for i = 1, #callback_data do
local item = callback_data[i]
local price = item.price
local df = item.distance_factor
if df then
local min_price = item.min_price or 1
price = item.price - d * df
price = math.max(price, min_price)
end
Retailer.set_item(
market_id,
{
name = item.name,
type = item.type,
price = price,
stack_limit = item.stack_limit,
name_label = item.name_label,
sprite = item.sprite,
disabled = item.disabled,
disabled_reason = item.disabled_reason,
description = item.description}
)
end
end
)
Public.firearm_magazine_ammo = {name = 'firearm-magazine', count = 200}
Public.piercing_rounds_magazine_ammo = {name = 'piercing-rounds-magazine', count = 200}
Public.uranium_rounds_magazine_ammo = {name = 'uranium-rounds-magazine', count = 200}
Public.artillery_shell_ammo = {name = 'artillery-shell', count = 15}
Public.light_oil_ammo = {name = 'light-oil', amount = 100}
Public.laser_turrent_power_source = {buffer_size = 2400000, power_production = 40000}
function Public.prepare_weighted_loot(loot)
local total = 0
local weights = {}
for i = 1, #loot do
local v = loot[i]
total = total + v.weight
weights[#weights + 1] = total
end
weights.total = total
return weights
end
function Public.do_random_loot(entity, weights, loot)
if not entity.valid then
return
end
entity.operable = false
--entity.destructible = false
local i = math.random() * weights.total
local index = table.binary_search(weights, i)
if (index < 0) then
index = bit32.bnot(index)
end
local stack = loot[index].stack
if not stack then
return
end
local df = stack.distance_factor
local count
if df then
local p = entity.position
local x, y = p.x, p.y
local d = math.sqrt(x * x + y * y)
count = stack.count + d * df
else
count = stack.count
end
entity.insert {name = stack.name, count = count}
end
function Public.do_random_fluid_loot(entity, weights, loot)
if not entity.valid then
return
end
entity.operable = false
entity.destructible = false
entity.force = 'player'
local i = math.random() * weights.total
local index = table.binary_search(weights, i)
if (index < 0) then
index = bit32.bnot(index)
end
local stack = loot[index].stack
if not stack then
return
end
local df = stack.distance_factor
local count
if df then
local p = entity.position
local x, y = p.x, p.y
local d = math.sqrt(x * x + y * y)
count = stack.count + d * df
else
count = stack.count
end
entity.fluidbox[1] = {name = stack.name, amount = count}
end
function Public.do_factory_loot(entity, weights, loot)
if not entity.valid then
return
end
entity.operable = false
entity.destructible = false
entity.force = 'player'
local i = math.random() * weights.total
local index = table.binary_search(weights, i)
if (index < 0) then
index = bit32.bnot(index)
end
local stack = loot[index].stack
if not stack then
return
end
local df = stack.distance_factor
local count
if df then
local p = entity.position
local x, y = p.x, p.y
local d = math.sqrt(x * x + y * y)
count = stack.count + d * df
else
count = stack.count
end
local name = stack.name
entity.set_recipe(name)
entity.get_output_inventory().insert {name = name, count = count}
end
local function market_selected(event)
local player = game.get_player(event.player_index)
if not player or not player.valid then
return
end
if player.render_mode == render_mode_game then
return
end
local selected = player.selected
if not selected or not selected.valid or selected.name ~= 'market' then
return
end
local group = Retailer.get_market_group_name(selected)
local prototype = Retailer.get_items(group)['upgrade']
if prototype.disabled then
return
end
local args = {
text = nil,
target = selected,
target_offset = nil,
alignment = 'center',
surface = selected.surface,
color = {1, 1, 1},
players = {player},
scale = 1.5,
scale_with_zoom = true,
time_to_live = 180
}
args.text = prototype.name_label
args.target_offset = {0, -6.5}
draw_text(args)
args.text = 'Price: ' .. prototype.price
args.target_offset = {0, -5}
draw_text(args)
args.text = prototype.mapview_description
args.target_offset = {0, -3.5}
draw_text(args)
end
Event.add(defines.events.on_tick, tick)
Event.add(defines.events.on_entity_died, turret_died)
Event.on_init(
function()
game.forces.neutral.recipes['steel-plate'].enabled = true
end
)
Event.add(Retailer.events.on_market_purchase, do_outpost_upgrade)
Event.add(defines.events.on_selected_entity_changed, market_selected)
Command.add(
'set-pollution-multiplier',
{
description = {'command_description.set_pollution_multiplier'},
arguments = {'multiplier'},
required_rank = Ranks.admin,
capture_excess_arguments = true,
allowed_by_server = true
},
set_pollution_multiplier
)
Command.add(
'get-pollution-multiplier',
{
description = {'command_description.get_pollution_multiplier'},
required_rank = Ranks.guest,
capture_excess_arguments = true,
allowed_by_server = true
},
get_pollution_multiplier
)
return Public