mirror of
https://github.com/ComfyFactory/ComfyFactorio.git
synced 2025-01-08 00:39:30 +02:00
694 lines
27 KiB
Lua
694 lines
27 KiB
Lua
--luacheck: ignore
|
|
local Event = require 'utils.event'
|
|
local HDT = require 'modules.hidden_dimension.table'
|
|
|
|
local Public = {}
|
|
Public.events = {
|
|
reset_game = Event.generate_event_name('reset_game'),
|
|
init_surfaces = Event.generate_event_name('init_surfaces')
|
|
}
|
|
|
|
--- If true then surface will be picked to nauvis.
|
|
Public.enable_auto_init = true
|
|
|
|
local deepcopy = table.deepcopy
|
|
local transport_table = HDT.transport_table
|
|
local levels_table = HDT.levels_table
|
|
local math_max = math.max
|
|
local table_insert = table.insert
|
|
|
|
local function get_table(t)
|
|
local key
|
|
local value
|
|
for k, v in pairs(t) do
|
|
key = k
|
|
value = v
|
|
end
|
|
return key, value
|
|
end
|
|
|
|
local function teleport(entity, pos, surface)
|
|
local sane_pos = surface.find_non_colliding_position(entity.name, pos, 0, 1, 1)
|
|
if entity.type == 'character' then
|
|
for k, v in pairs(game.players) do
|
|
if v.character == entity then
|
|
v.teleport(sane_pos, surface)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function clear_surroundings(surface, pos)
|
|
local entity = surface.find_entities(pos)
|
|
for i, _ in ipairs(entity) do
|
|
if entity[i].type ~= 'character' then
|
|
entity[i].destroy()
|
|
else
|
|
teleport(entity[i], {0, 0}, entity[i].surface)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function transport_resources(container1, container2, transport_type)
|
|
if container1 == nil or container2 == nil then
|
|
return
|
|
end
|
|
|
|
if not container1.valid or not container2.valid then
|
|
return
|
|
end
|
|
|
|
local function average(c1c, c2c)
|
|
local average_content = (c1c + c2c) / 2
|
|
c1c = average_content
|
|
c2c = average_content
|
|
return c1c, c2c
|
|
end
|
|
|
|
local function get_steam_temperature(container)
|
|
local temperature = 0
|
|
|
|
local function test_for(temp)
|
|
local count = container.remove_fluid({name = 'steam', amount = 1, temperature = temp})
|
|
if count ~= 0 then
|
|
temperature = temp
|
|
else
|
|
return
|
|
end
|
|
container.insert_fluid({name = 'steam', amount = count, temperature = temp})
|
|
end
|
|
|
|
test_for(15)
|
|
if temperature == 0 then
|
|
test_for(165)
|
|
if temperature == 0 then
|
|
test_for(500)
|
|
if temperature == 0 then
|
|
temperature = 165
|
|
end
|
|
end
|
|
end
|
|
return temperature
|
|
end
|
|
|
|
local function divide_fluids()
|
|
local af = container1.get_fluid_contents()
|
|
local bf = container2.get_fluid_contents()
|
|
local name1, amount1 = get_table(af)
|
|
local name2, amount2 = get_table(bf)
|
|
amount1 = amount1 or 0
|
|
amount2 = amount2 or 0
|
|
if ((not name1 and not name2) or (name1 and name2 and name1 ~= name2) or (amount1 < 1 and amount2 < 1) or (amount1 == amount2)) then
|
|
return
|
|
end
|
|
if (not name1) then
|
|
name1 = name2
|
|
elseif (not name2) then
|
|
name2 = name1
|
|
end
|
|
local v = (amount1 + amount2) / 2
|
|
if (name1 == 'steam') then
|
|
local temp
|
|
local at = get_steam_temperature(container1)
|
|
local bt = get_steam_temperature(container2)
|
|
temp = math_max(at, bt)
|
|
container1.clear_fluid_inside()
|
|
container2.clear_fluid_inside()
|
|
container1.insert_fluid({name = name1, amount = v, temperature = temp})
|
|
container2.insert_fluid({name = name2, amount = v, temperature = temp})
|
|
else
|
|
container1.clear_fluid_inside()
|
|
container2.clear_fluid_inside()
|
|
container1.insert_fluid({name = name1, amount = v})
|
|
container2.insert_fluid({name = name2, amount = v})
|
|
end
|
|
end
|
|
|
|
local function divide_contents()
|
|
local chest1 = container1.get_inventory(defines.inventory.chest)
|
|
local chest2 = container2.get_inventory(defines.inventory.chest)
|
|
for k, v in pairs(chest1.get_contents()) do
|
|
local t = {name = k, count = v}
|
|
local c = chest2.insert(t)
|
|
if (c > 0) then
|
|
chest1.remove({name = k, count = c})
|
|
end
|
|
end
|
|
end
|
|
|
|
if container1.type == 'container' and container2.type == 'container' then
|
|
if transport_type == 'in-out' then
|
|
divide_contents()
|
|
end
|
|
elseif container1.type == 'pipe-to-ground' and container2.type == 'pipe-to-ground' then
|
|
divide_fluids()
|
|
else
|
|
if transport_type == 'average' then
|
|
if container1.temperature and container2.temperature then
|
|
container1.temperature, container2.temperature = average(container1.temperature, container2.temperature)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function create_underground_floor(surface, size, going_down)
|
|
local function tile_generation(floor_type, offset_pos, floor_pos, floor_area)
|
|
local area = {}
|
|
if type(floor_area) == 'table' then
|
|
area.x = floor_area.x
|
|
area.y = floor_area.y
|
|
else
|
|
area.x = floor_area
|
|
area.y = floor_area
|
|
end
|
|
|
|
local pos = {}
|
|
pos.x = floor_pos.x + offset_pos.x
|
|
pos.y = floor_pos.y + offset_pos.y
|
|
local tiles = {}
|
|
for i = 0, area.x - 1 do
|
|
for j = 0, area.y - 1 do
|
|
table_insert(tiles, {name = floor_type, position = {i + pos.x, j + pos.y}})
|
|
end
|
|
end
|
|
|
|
surface.set_tiles(tiles)
|
|
end
|
|
tile_generation('tutorial-grid', {x = 0, y = 0}, {x = -size / 2, y = -size / 2}, {x = size - 1, y = size})
|
|
tile_generation('black-refined-concrete', {x = 0, y = 0}, {x = -size / 2, y = -size / 2}, {x = size - 1, y = size})
|
|
tile_generation('hazard-concrete-left', {x = 0, y = 0}, {x = -3, y = -7}, {x = 6, y = 3})
|
|
|
|
if going_down then
|
|
tile_generation('hazard-concrete-left', {x = 0, y = 0}, {x = -3, y = 3}, {x = 6, y = 3})
|
|
tile_generation('hazard-concrete-left', {x = 0, y = 0}, {x = -2, y = -2}, {x = 4, y = 3})
|
|
else
|
|
tile_generation('black-refined-concrete', {x = 0, y = 0}, {x = -size / 2, y = -size / 2}, {x = size - 1, y = size})
|
|
end
|
|
end
|
|
|
|
local function create_main_surface(rebuild)
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
local name = hidden_dimension.hd_surface
|
|
local position = hidden_dimension.position
|
|
|
|
if not game.surfaces[name] then
|
|
return
|
|
end
|
|
|
|
if not game.surfaces[name].valid then
|
|
return
|
|
end
|
|
|
|
local surface = game.surfaces[name]
|
|
|
|
if rebuild then
|
|
hidden_dimension.main_surface.reference =
|
|
surface.create_entity {
|
|
name = 'car',
|
|
position = position,
|
|
force = game.forces.enemy,
|
|
create_build_effect_smoke = false
|
|
}
|
|
hidden_dimension.main_surface.reference.minable = false
|
|
hidden_dimension.main_surface.reference.destructible = false
|
|
hidden_dimension.main_surface.reference.operable = false
|
|
hidden_dimension.main_surface.reference.get_inventory(defines.inventory.fuel).insert({name = 'coal', count = 100})
|
|
return
|
|
end
|
|
if not hidden_dimension.main_surface.reference or not hidden_dimension.main_surface.reference.valid then
|
|
hidden_dimension.main_surface.reference =
|
|
surface.create_entity {
|
|
name = 'car',
|
|
position = {position.x, position.y - 23},
|
|
force = game.forces.enemy,
|
|
create_build_effect_smoke = false
|
|
}
|
|
hidden_dimension.main_surface.reference.minable = false
|
|
hidden_dimension.main_surface.reference.destructible = false
|
|
hidden_dimension.main_surface.reference.operable = false
|
|
hidden_dimension.main_surface.reference.get_inventory(defines.inventory.fuel).insert({name = 'coal', count = 100})
|
|
if hidden_dimension.logistic_research_level == 0 then
|
|
return
|
|
end
|
|
Public.create_chests(hidden_dimension.main_surface, hidden_dimension.logistic_research_level, 'in_and_out')
|
|
end
|
|
end
|
|
|
|
local function create_underground_surfaces()
|
|
local function create_underground(floor_table, name, going_down)
|
|
--local underground_level
|
|
floor_table.surface = game.create_surface(name, {width = 14, height = 16})
|
|
floor_table.surface.always_day = true
|
|
floor_table.surface.daytime = 0.5
|
|
floor_table.surface.request_to_generate_chunks({0, 0}, 10)
|
|
floor_table.surface.force_generate_chunk_requests()
|
|
local clear_ent = floor_table.surface.find_entities()
|
|
for i, _ in ipairs(clear_ent) do
|
|
clear_ent[i].destroy()
|
|
end
|
|
floor_table.name = name
|
|
floor_table.size = 16
|
|
|
|
floor_table.surface.destroy_decoratives({area = {{-floor_table.size, -floor_table.size}, {floor_table.size, floor_table.size}}})
|
|
|
|
create_underground_floor(floor_table.surface, floor_table.size, going_down)
|
|
|
|
floor_table.going_up.reference =
|
|
floor_table.surface.create_entity {
|
|
name = 'car',
|
|
position = {0, -6},
|
|
force = game.forces.enemy,
|
|
create_build_effect_smoke = false
|
|
}
|
|
rendering.draw_light(
|
|
{
|
|
sprite = 'utility/light_medium',
|
|
scale = 5.5,
|
|
intensity = 1,
|
|
minimum_darkness = 0,
|
|
oriented = true,
|
|
color = {255, 255, 255},
|
|
target = floor_table.going_up.reference,
|
|
surface = floor_table.surface,
|
|
visible = true,
|
|
only_in_alt_mode = false
|
|
}
|
|
)
|
|
floor_table.going_up.reference.minable = false
|
|
floor_table.going_up.reference.destructible = false
|
|
floor_table.going_up.reference.operable = false
|
|
floor_table.going_up.reference.get_inventory(defines.inventory.fuel).insert({name = 'coal', count = 100})
|
|
|
|
if going_down then
|
|
floor_table.going_down.reference =
|
|
floor_table.surface.create_entity {
|
|
name = 'car',
|
|
position = {0, 4},
|
|
force = game.forces.enemy,
|
|
create_build_effect_smoke = false
|
|
}
|
|
floor_table.going_down.reference.minable = false
|
|
floor_table.going_down.reference.destructible = false
|
|
floor_table.going_down.reference.operable = false
|
|
floor_table.going_down.reference.get_inventory(defines.inventory.fuel).insert({name = 'coal', count = 100})
|
|
|
|
rendering.draw_light(
|
|
{
|
|
sprite = 'utility/light_medium',
|
|
scale = 5.5,
|
|
intensity = 1,
|
|
minimum_darkness = 0,
|
|
oriented = true,
|
|
color = {255, 255, 255},
|
|
target = floor_table.going_down.reference,
|
|
surface = floor_table.surface,
|
|
visible = true,
|
|
only_in_alt_mode = false
|
|
}
|
|
)
|
|
end
|
|
end
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
if not hidden_dimension.reset_counter then
|
|
hidden_dimension.reset_counter = 1
|
|
else
|
|
hidden_dimension.reset_counter = hidden_dimension.reset_counter + 1
|
|
end
|
|
|
|
create_underground(hidden_dimension.level_1, 'level_1_' .. tostring(hidden_dimension.reset_counter), true)
|
|
create_underground(hidden_dimension.level_2, 'level_2_' .. tostring(hidden_dimension.reset_counter), false)
|
|
end
|
|
|
|
local function reset_surface()
|
|
HDT.reset_table()
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
hidden_dimension.logistic_research_level = 0
|
|
|
|
hidden_dimension.level_1.going_down.entities = {}
|
|
hidden_dimension.level_1.going_up.entities = {}
|
|
hidden_dimension.level_2.going_down.entities = {}
|
|
hidden_dimension.level_2.going_up.entities = {}
|
|
hidden_dimension.main_surface.entities = {}
|
|
|
|
game.delete_surface('level_1_' .. tostring(hidden_dimension.reset_counter))
|
|
game.delete_surface('level_2_' .. tostring(hidden_dimension.reset_counter))
|
|
create_underground_surfaces()
|
|
end
|
|
|
|
local function logistic_update()
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
local name = hidden_dimension.hd_surface
|
|
|
|
if not game.surfaces[name] then
|
|
return
|
|
end
|
|
|
|
if not game.surfaces[name].valid then
|
|
return
|
|
end
|
|
|
|
local function energy_update(t)
|
|
local g = 0
|
|
local c = 0
|
|
for k, v in pairs(t) do
|
|
if (v.valid) then
|
|
g = g + v.energy
|
|
c = c + v.electric_buffer_size
|
|
end
|
|
end
|
|
for k, v in pairs(t) do
|
|
if (v.valid) then
|
|
local r = (v.electric_buffer_size / c)
|
|
v.energy = g * r
|
|
end
|
|
end
|
|
end
|
|
|
|
local function entrance_transport_resources(transport1, transport2)
|
|
transport_resources(transport1.reference, transport2.reference, 'average')
|
|
|
|
if transport1.transport_type == 'out_and_out' then
|
|
transport_resources(transport2.entities.chest_1, transport1.entities.chest_1, 'in-out')
|
|
transport_resources(transport2.entities.chest_2, transport1.entities.chest_2, 'in-out')
|
|
elseif transport1.transport_type == 'in_and_out' then
|
|
transport_resources(transport1.entities.chest_1, transport2.entities.chest_1, 'in-out')
|
|
transport_resources(transport2.entities.chest_2, transport1.entities.chest_2, 'in-out')
|
|
end
|
|
|
|
transport_resources(transport1.entities.pipe_1, transport2.entities.pipe_1, 'in-out')
|
|
transport_resources(transport2.entities.pipe_2, transport1.entities.pipe_2, 'in-out')
|
|
|
|
if hidden_dimension.logistic_research_level > 1 then
|
|
transport_resources(transport1.entities.pipe_3, transport2.entities.pipe_3, 'in-out')
|
|
transport_resources(transport2.entities.pipe_4, transport1.entities.pipe_4, 'in-out')
|
|
|
|
if hidden_dimension.logistic_research_level > 2 then
|
|
transport_resources(transport1.entities.pipe_5, transport2.entities.pipe_5, 'in-out')
|
|
transport_resources(transport2.entities.pipe_6, transport1.entities.pipe_6, 'in-out')
|
|
end
|
|
end
|
|
end
|
|
|
|
entrance_transport_resources(hidden_dimension.main_surface, hidden_dimension.level_1.going_up)
|
|
|
|
entrance_transport_resources(hidden_dimension.level_1.going_down, hidden_dimension.level_2.going_up)
|
|
|
|
transport_resources(hidden_dimension.level_1.going_down.reference, hidden_dimension.level_1.going_up.reference, 'average')
|
|
|
|
energy_update(hidden_dimension.energy)
|
|
end
|
|
|
|
local function on_research_finished(event)
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
|
|
if event.research.name == 'automation' or event.research.name == 'automation-2' or event.research.name == 'automation-3' then
|
|
if event.research.name == 'automation' then
|
|
hidden_dimension.level_1.size = 32
|
|
hidden_dimension.level_2.size = 32
|
|
create_underground_floor(hidden_dimension.level_1.surface, hidden_dimension.level_1.size, true)
|
|
create_underground_floor(hidden_dimension.level_2.surface, hidden_dimension.level_1.size, false)
|
|
elseif event.research.name == 'automation-2' then
|
|
hidden_dimension.level_1.size = 64
|
|
create_underground_floor(hidden_dimension.level_1.surface, hidden_dimension.level_1.size, true)
|
|
elseif event.research.name == 'automation-3' then
|
|
hidden_dimension.level_2.size = 64
|
|
create_underground_floor(hidden_dimension.level_2.surface, hidden_dimension.level_1.size, false)
|
|
end
|
|
elseif event.research.name == 'logistics' then
|
|
hidden_dimension.logistic_research_level = 1
|
|
Public.create_chests_logistics(1)
|
|
elseif event.research.name == 'logistics-2' then
|
|
hidden_dimension.logistic_research_level = 2
|
|
Public.upgrade_transport_buildings(2)
|
|
elseif event.research.name == 'logistics-3' then
|
|
hidden_dimension.logistic_research_level = 3
|
|
Public.upgrade_transport_buildings(3)
|
|
elseif event.research.name == 'electric-energy-accumulators' then
|
|
-- fix power
|
|
end
|
|
end
|
|
|
|
local function through_teleporter_update()
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
local function teleport_players_around(source, destination)
|
|
if source == nil or source.valid ~= true then
|
|
return
|
|
end
|
|
if destination == nil or (not destination.valid) then
|
|
return
|
|
end
|
|
|
|
local function surface_play_sound(sound_path, surface, pos)
|
|
for k, v in pairs(game.connected_players) do
|
|
if v.surface.name == surface then
|
|
v.play_sound {path = sound_path, position = pos}
|
|
end
|
|
end
|
|
end
|
|
|
|
local to_teleport_out_entity_list =
|
|
source.surface.find_entities_filtered {
|
|
area = {
|
|
{source.position.x - 1.1, source.position.y - 1.1},
|
|
{source.position.x + 1.1, source.position.y + 1.1}
|
|
},
|
|
type = 'character'
|
|
}
|
|
for i, v in ipairs(to_teleport_out_entity_list) do
|
|
if v.type == 'character' then
|
|
local pos = {x = destination.position.x, y = destination.position.y}
|
|
if v.position.y < source.position.y then
|
|
pos.y = pos.y + 2
|
|
else
|
|
pos.y = pos.y - 2
|
|
end
|
|
teleport(v, pos, destination.surface)
|
|
local sound = 'utility/wire_connect_pole'
|
|
surface_play_sound(sound, source.surface.name, source.position)
|
|
surface_play_sound(sound, destination.surface.name, destination.position)
|
|
end
|
|
end
|
|
end
|
|
|
|
if hidden_dimension.main_surface and hidden_dimension.main_surface.reference then
|
|
teleport_players_around(hidden_dimension.main_surface.reference, hidden_dimension.level_1.going_up.reference)
|
|
end
|
|
if hidden_dimension.level_1 and hidden_dimension.level_1.going_up and hidden_dimension.level_1.going_up.reference then
|
|
teleport_players_around(hidden_dimension.level_1.going_up.reference, hidden_dimension.main_surface.reference)
|
|
end
|
|
|
|
if hidden_dimension.level_1 and hidden_dimension.level_1.going_down and hidden_dimension.level_1.going_down.reference then
|
|
teleport_players_around(hidden_dimension.level_1.going_down.reference, hidden_dimension.level_2.going_up.reference)
|
|
end
|
|
if hidden_dimension.level_2 and hidden_dimension.level_2.going_up and hidden_dimension.level_2.going_up.reference then
|
|
teleport_players_around(hidden_dimension.level_2.going_up.reference, hidden_dimension.level_1.going_down.reference)
|
|
end
|
|
end
|
|
|
|
local function on_entity_cloned(event)
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
for k, v in pairs(hidden_dimension.main_surface.entities) do
|
|
if event.source == v then
|
|
event.destination.destroy()
|
|
end
|
|
end
|
|
hidden_dimension.main_surface.reference.destroy()
|
|
end
|
|
|
|
local function on_player_joined_game(event)
|
|
if event.player_index == 1 then
|
|
create_underground_surfaces()
|
|
|
|
create_main_surface(true)
|
|
end
|
|
end
|
|
|
|
local function on_tick(e)
|
|
if e.tick % 5 then
|
|
logistic_update()
|
|
if e.tick % 30 then
|
|
create_main_surface()
|
|
through_teleporter_update()
|
|
end
|
|
end
|
|
end
|
|
|
|
local function on_init()
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
hidden_dimension.level_1 = deepcopy(levels_table)
|
|
hidden_dimension.level_2 = deepcopy(levels_table)
|
|
hidden_dimension.main_surface = deepcopy(transport_table)
|
|
end
|
|
|
|
--- If a different surface is wanted then this should be called
|
|
-- with:
|
|
-- local HD = require 'modules.hidden_dimension.main'
|
|
-- HD.init({hd_surface = some_surface})
|
|
function Public.init(args)
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
if args then
|
|
hidden_dimension.position = args.position or {x = 0, y = 3}
|
|
hidden_dimension.hd_surface = args.hd_surface or 'nauvis'
|
|
else
|
|
hidden_dimension.hd_surface = 'nauvis'
|
|
hidden_dimension.position = {x = 0, y = 3}
|
|
end
|
|
end
|
|
|
|
function Public.create_chests(surface, level, build_type)
|
|
surface.transport_type = build_type
|
|
local direction1
|
|
local direction2
|
|
local rotation1
|
|
local rotation2
|
|
if build_type == 'in_and_out' then
|
|
direction1 = defines.direction.south
|
|
direction2 = defines.direction.north
|
|
rotation1 = 'input'
|
|
rotation2 = 'output'
|
|
elseif build_type == 'out_and_in' then
|
|
direction1 = defines.direction.north
|
|
direction2 = defines.direction.south
|
|
rotation1 = 'output'
|
|
rotation2 = 'input'
|
|
elseif build_type == 'in_and_in' then
|
|
direction1 = defines.direction.south
|
|
direction2 = defines.direction.south
|
|
rotation1 = 'input'
|
|
rotation2 = 'input'
|
|
else
|
|
direction1 = defines.direction.north
|
|
direction2 = defines.direction.north
|
|
rotation1 = 'output'
|
|
rotation2 = 'output'
|
|
end
|
|
local logistic_building = surface.reference
|
|
local energy = 'electric-energy-interface'
|
|
local loader
|
|
local chest = 'blue-chest'
|
|
if level == 1 then
|
|
loader = 'loader'
|
|
elseif level == 2 then
|
|
loader = 'fast-loader'
|
|
else
|
|
loader = 'express-loader'
|
|
end
|
|
|
|
local function add_container(name, pos, direction, type)
|
|
local container_entity
|
|
container_entity = logistic_building.surface.find_entity(name, {logistic_building.position.x + pos.x, logistic_building.position.y + pos.y})
|
|
if container_entity == nil then
|
|
local pos2 = {logistic_building.position.x + pos.x, logistic_building.position.y + pos.y}
|
|
if name == 'loader' or name == 'fast-loader' or name == 'express-loader' then
|
|
container_entity =
|
|
logistic_building.surface.create_entity {
|
|
name = name,
|
|
position = pos2,
|
|
force = game.forces.player,
|
|
type = type
|
|
}
|
|
container_entity.direction = direction
|
|
elseif name == 'pipe-to-ground' then
|
|
container_entity = logistic_building.surface.create_entity {name = name, position = pos2, force = game.forces.player}
|
|
container_entity.direction = direction
|
|
elseif name == energy then
|
|
container_entity = logistic_building.surface.create_entity {name = name, position = pos2, force = game.forces.player}
|
|
container_entity.minable = false
|
|
container_entity.destructible = false
|
|
container_entity.operable = false
|
|
container_entity.power_production = 0
|
|
container_entity.electric_buffer_size = 10000000
|
|
else
|
|
container_entity = logistic_building.surface.create_entity {name = name, position = pos2, force = game.forces.player}
|
|
end
|
|
end
|
|
container_entity.minable = false
|
|
container_entity.destructible = false
|
|
return container_entity
|
|
end
|
|
|
|
surface.entities.loader_1 = add_container(loader, {x = -2, y = 0}, direction1, rotation1)
|
|
surface.entities.loader_2 = add_container(loader, {x = 1, y = 0}, direction2, rotation2)
|
|
surface.entities.chest_1 = add_container(chest, {x = -2, y = 1})
|
|
surface.entities.chest_2 = add_container(chest, {x = 1, y = 1})
|
|
surface.entities.pipe_1 = add_container('pipe-to-ground', {x = -3, y = 1}, defines.direction.west)
|
|
surface.entities.pipe_2 = add_container('pipe-to-ground', {x = 2, y = 1}, defines.direction.east)
|
|
if level > 1 then
|
|
surface.entities.pipe_3 = add_container('pipe-to-ground', {x = -3, y = 0}, defines.direction.west)
|
|
surface.entities.pipe_4 = add_container('pipe-to-ground', {x = 2, y = 0}, defines.direction.east)
|
|
if level > 2 then
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
hidden_dimension.energy[#hidden_dimension.energy + 1] = add_container(energy, {x = 0, y = 0})
|
|
surface.entities.pipe_5 = add_container('pipe-to-ground', {x = -3, y = -1}, defines.direction.west)
|
|
surface.entities.pipe_6 = add_container('pipe-to-ground', {x = 2, y = -1}, defines.direction.east)
|
|
end
|
|
end
|
|
end
|
|
|
|
function Public.upgrade_transport_buildings(level)
|
|
local function upgrade(transport, building_type)
|
|
local function copy_chest_content(content, chest)
|
|
for k, v in pairs(content) do
|
|
chest.insert({name = k, count = v})
|
|
end
|
|
end
|
|
|
|
if transport.reference == nil or transport.reference.valid ~= true then
|
|
return
|
|
end
|
|
if transport.entities.chest_1 == nil or transport.entities.chest_1.valid ~= true then
|
|
return
|
|
end
|
|
|
|
local chest_1_inventory = transport.entities.chest_1.get_inventory(defines.inventory.chest).get_contents()
|
|
local chest_2_inventory = transport.entities.chest_2.get_inventory(defines.inventory.chest).get_contents()
|
|
|
|
local pos = transport.reference.position
|
|
local logistic_bb = {{pos.x - 5, pos.y - 5}, {pos.x + 5, pos.y + 5}}
|
|
|
|
local surface = transport.reference.surface
|
|
|
|
clear_surroundings(transport.reference.surface, logistic_bb)
|
|
|
|
transport.reference = surface.create_entity {name = building_type, position = pos, force = game.forces.enemy}
|
|
transport.reference.minable = false
|
|
transport.reference.destructible = false
|
|
transport.reference.operable = false
|
|
transport.reference.get_inventory(defines.inventory.fuel).insert({name = 'coal', count = 100})
|
|
|
|
Public.create_chests(transport, level, transport.transport_type)
|
|
|
|
copy_chest_content(chest_1_inventory, transport.entities.chest_1)
|
|
copy_chest_content(chest_2_inventory, transport.entities.chest_2)
|
|
end
|
|
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
|
|
upgrade(hidden_dimension.level_1.going_up, 'car')
|
|
upgrade(hidden_dimension.level_1.going_down, 'car')
|
|
upgrade(hidden_dimension.level_2.going_up, 'car')
|
|
upgrade(hidden_dimension.main_surface, 'car')
|
|
end
|
|
|
|
function Public.create_chests_logistics(level)
|
|
local hidden_dimension = HDT.get('hidden_dimension')
|
|
Public.create_chests(hidden_dimension.main_surface, level, 'in_and_out')
|
|
Public.create_chests(hidden_dimension.level_1.going_up, level, 'out_and_in')
|
|
Public.create_chests(hidden_dimension.level_1.going_down, level, 'in_and_out')
|
|
Public.create_chests(hidden_dimension.level_2.going_up, level, 'out_and_in')
|
|
end
|
|
|
|
if Public.enable_auto_init then
|
|
Public.init()
|
|
end
|
|
|
|
Event.on_init(on_init)
|
|
Event.add(defines.events.on_player_joined_game, on_player_joined_game)
|
|
Event.add(defines.events.on_tick, on_tick)
|
|
Event.add(defines.events.on_research_finished, on_research_finished)
|
|
Event.add(defines.events.on_entity_cloned, on_entity_cloned)
|
|
Event.add(Public.events.reset_game, reset_surface)
|
|
Event.add(Public.events.init_surfaces, create_underground_surfaces)
|
|
|
|
return Public
|