Fix runtime scripts
This commit is contained in:
Simon Brodtmann
parent
c1a4429c80
commit
447c47f0f3
7 changed files with 191 additions and 191 deletions
|
|
@ -119,7 +119,7 @@ return function(mod_name)
|
|||
--~ log("Entered function get_tree_ignore_list!")
|
||||
local ignore = {}
|
||||
local trees = game and
|
||||
game.get_filtered_entity_prototypes({{filter = "type", type = "tree"}}) or
|
||||
prototypes.get_entity_filtered({{filter = "type", type = "tree"}}) or
|
||||
data.raw.tree
|
||||
for tree_name, tree in pairs(trees) do
|
||||
--~ log("tree_name: " .. tree_name)
|
||||
|
|
@ -281,7 +281,7 @@ return function(mod_name)
|
|||
local ret = false
|
||||
|
||||
if game then
|
||||
local AB = game.item_prototypes["fertilizer"].place_as_tile_result.result.name
|
||||
local AB = prototypes.item["fertilizer"].place_as_tile_result.result.name
|
||||
-- In data stage, place_as_tile is only changed to Alien Biomes tiles if
|
||||
-- both "vegetation-green-grass-1" and "vegetation-green-grass-3" exist. Therefore,
|
||||
-- we only need to check for one tile in the control stage.
|
||||
|
|
@ -316,7 +316,7 @@ return function(mod_name)
|
|||
common.show("base_name", c_name)
|
||||
common.show("data", c_data)
|
||||
-- Is the base entity in the game?
|
||||
if c_data.base and c_data.base.name and game.entity_prototypes[c_data.base.name] then
|
||||
if c_data.base and c_data.base.name and prototypes.entity[c_data.base.name] then
|
||||
-- Make a copy of the compound-entity data
|
||||
common.writeDebug("%s exists -- copying data", {c_name})
|
||||
ret[c_name] = util.table.deepcopy(c_data)
|
||||
|
|
@ -326,7 +326,7 @@ common.show("data", c_data)
|
|||
--~ h_type = common.HE_map[h_key]
|
||||
common.writeDebug("h_key: %s\th_data: %s", {h_key, h_data})
|
||||
-- Remove hidden entity if it doesn't exist
|
||||
if not game.entity_prototypes[h_data.name] then
|
||||
if not prototypes.entity[h_data.name] then
|
||||
common.writeDebug("Removing %s (%s) from list of hidden entities!", {h_data.name, h_key})
|
||||
ret[c_name].hidden[h_key] = nil
|
||||
end
|
||||
|
|
@ -338,7 +338,7 @@ common.writeDebug("h_key: %s\th_data: %s", {h_key, h_data})
|
|||
if tab then
|
||||
-- Remove main table from global
|
||||
common.writeDebug("Removing %s (%s obsolete entries)", {tab, #tab})
|
||||
global[tab] = nil
|
||||
storage[tab] = nil
|
||||
end
|
||||
|
||||
-- If this compound entity requires additional tables in global, initialize
|
||||
|
|
@ -346,8 +346,8 @@ common.writeDebug("h_key: %s\th_data: %s", {h_key, h_data})
|
|||
local related_tables = c_data.add_global_tables
|
||||
if related_tables then
|
||||
for t, tab in ipairs(related_tables or {}) do
|
||||
common.writeDebug("Removing global[%s] (%s values)", {tab, table_size(global[tab])})
|
||||
global[tab] = nil
|
||||
common.writeDebug("Removing storage[%s] (%s values)", {tab, table_size(storage[tab])})
|
||||
storage[tab] = nil
|
||||
end
|
||||
end
|
||||
|
||||
|
|
@ -355,9 +355,9 @@ common.writeDebug("h_key: %s\th_data: %s", {h_key, h_data})
|
|||
local related_vars = c_data.add_global_values
|
||||
if related_vars then
|
||||
for var_name, value in pairs(related_vars or {}) do
|
||||
common.writeDebug("Removing global[%s] (was: %s)",
|
||||
{var_name, var_name and global[var_name] or "nil"})
|
||||
global[var_name] = nil
|
||||
common.writeDebug("Removing storage[%s] (was: %s)",
|
||||
{var_name, var_name and storage[var_name] or "nil"})
|
||||
storage[var_name] = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -370,18 +370,18 @@ common.writeDebug("h_key: %s\th_data: %s", {h_key, h_data})
|
|||
common.add_optional_data = function(base)
|
||||
local f_name = "add_optional_data"
|
||||
common.writeDebug("Entered function %s(%s)", {f_name, common.print_name_id(base)})
|
||||
if not (base and base.valid and global.compound_entities[base.name]) then
|
||||
if not (base and base.valid and storage.compound_entities[base.name]) then
|
||||
common.arg_err(base, "base of a compound entity")
|
||||
end
|
||||
|
||||
-- Add optional values to global table
|
||||
local data = global.compound_entities[base.name]
|
||||
local data = storage.compound_entities[base.name]
|
||||
common.show("data", data)
|
||||
local tab = data.tab
|
||||
common.show("tab", tab)
|
||||
common.show("global[tab]", global[tab] or "nil")
|
||||
common.show("storage[tab]", storage[tab] or "nil")
|
||||
|
||||
local entry = global[tab][base.unit_number]
|
||||
local entry = storage[tab][base.unit_number]
|
||||
|
||||
for k, v in pairs(data.optional or {}) do
|
||||
if entry[k] then
|
||||
|
|
@ -399,15 +399,15 @@ common.show("global[tab]", global[tab] or "nil")
|
|||
common.clean_global_compounds_table = function(entity_name)
|
||||
local f_name = "clean_table"
|
||||
common.writeDebug("Entered function %s(%s)", {f_name, entity_name or "nil"})
|
||||
common.writeDebug("Entries in common.compound_entities[%s]: %s", {entity_name, table_size(global.compound_entities[entity_name])})
|
||||
common.writeDebug("Entries in common.compound_entities[%s]: %s", {entity_name, table_size(storage.compound_entities[entity_name])})
|
||||
|
||||
--~ local entity_table = global[common.compound_entities[entity_name].tab]
|
||||
--~ local entity_table = storage[common.compound_entities[entity_name].tab]
|
||||
--~ local hidden_entities = common.compound_entities[entity_name].hidden
|
||||
local entity_table = global.compound_entities[entity_name]
|
||||
local entity_table = storage.compound_entities[entity_name]
|
||||
common.show("entity_table", entity_table and entity_table.tab)
|
||||
entity_table = entity_table and entity_table.tab and global[entity_table.tab]
|
||||
entity_table = entity_table and entity_table.tab and storage[entity_table.tab]
|
||||
common.writeDebug("entity_table: %s", {entity_table}, "line")
|
||||
local hidden_entities = global.compound_entities[entity_name].hidden
|
||||
local hidden_entities = storage.compound_entities[entity_name].hidden
|
||||
common.show("hidden_entities", hidden_entities)
|
||||
local removed = 0
|
||||
-- Scan the whole table
|
||||
|
|
@ -438,11 +438,11 @@ common.show("Pruned list size", table_size(entity_table))
|
|||
common.restore_missing_entities = function(entity_name)
|
||||
local f_name = "restore_missing_entities"
|
||||
common.writeDebug("Entered function %s(%s)", {f_name, entity_name or "nil"})
|
||||
--~ common.writeDebug("global.compound_entities[%s]: %s", {entity_name, global.compound_entities[entity_name]})
|
||||
common.writeDebug("global.compound_entities[%s]: %s entries", {entity_name, table_size(global.compound_entities[entity_name])})
|
||||
--~ common.writeDebug("storage.compound_entities[%s]: %s", {entity_name, storage.compound_entities[entity_name]})
|
||||
common.writeDebug("storage.compound_entities[%s]: %s entries", {entity_name, table_size(storage.compound_entities[entity_name])})
|
||||
|
||||
local check = global.compound_entities[entity_name]
|
||||
local entity_table = check and global[check.tab] or {}
|
||||
local check = storage.compound_entities[entity_name]
|
||||
local entity_table = check and storage[check.tab] or {}
|
||||
local hidden_entities = check and check.hidden or {}
|
||||
|
||||
local checked = 0
|
||||
|
|
@ -485,12 +485,12 @@ common.writeDebug("Restored %s entities", {restored})
|
|||
|
||||
local cnt = 0
|
||||
local h_cnt = 0
|
||||
local data = global.compound_entities[compound_name]
|
||||
local data = storage.compound_entities[compound_name]
|
||||
if not data then
|
||||
common.arg_err(compound_name, "name of a compound entity")
|
||||
end
|
||||
|
||||
local g_tab = global[data.tab]
|
||||
local g_tab = storage[data.tab]
|
||||
local found, h_found ,created
|
||||
|
||||
-- Scan all surfaces
|
||||
|
|
@ -553,7 +553,7 @@ common.writeDebug("Restored %s entities", {restored})
|
|||
common.writeDebug("Entered function %s()", {f_name})
|
||||
|
||||
local cnt = 0
|
||||
for compound_entity, c in pairs(global.compound_entities) do
|
||||
for compound_entity, c in pairs(storage.compound_entities) do
|
||||
cnt = cnt + common.register_in_compound_entity_tab(compound_entity)
|
||||
end
|
||||
--~ common.writeDebug("Registered %s compound entities", {cnt})
|
||||
|
|
@ -647,7 +647,7 @@ common.show("new", {x = base_pos.x + offset.x, y = base_pos.y + offset.y})
|
|||
for key, tab in pairs(hidden_entities) do
|
||||
common.writeDebug("key: %s\tname: %s", {key, tab})
|
||||
--~ data = common.compound_entities[base_entity.name].hidden[key]
|
||||
data = global.compound_entities[base_entity.name].hidden[key]
|
||||
data = storage.compound_entities[base_entity.name].hidden[key]
|
||||
--~ common.show("common.compound_entities[base_entity.name].hidden",
|
||||
--~ common.compound_entities[base_entity.name].hidden)
|
||||
common.show("data", data)
|
||||
|
|
@ -671,7 +671,7 @@ common.show("data", data)
|
|||
end
|
||||
|
||||
-- Add optional values to global table
|
||||
--~ local optional = global.compound_entities[base_entity.name].optional
|
||||
--~ local optional = storage.compound_entities[base_entity.name].optional
|
||||
--~ for k, v in pairs(optional or {}) do
|
||||
--~ g_table[base_entity.unit_number][k] = v
|
||||
--~ end
|
||||
|
|
@ -688,7 +688,7 @@ common.show("data", data)
|
|||
if common.get_startup_setting("BI_Easy_Bio_Gardens") then
|
||||
common.writeDebug("\"Easy gardens\": Compiling list of poles they can connect to!" )
|
||||
ret = {}
|
||||
local poles = game.get_filtered_entity_prototypes({
|
||||
local poles = prototypes.get_entity_filtered({
|
||||
{filter = "type", type = "electric-pole"},
|
||||
{filter = "name", name = {
|
||||
-- Poles named here will be ignored!
|
||||
|
|
@ -713,23 +713,23 @@ common.writeDebug("\"Easy gardens\": Not active -- nothing to do!" )
|
|||
-- added to the table yet if the pole has just been built. In this
|
||||
-- case, we pass on the new pole explicitly!)
|
||||
common.connect_garden_pole = function(base, new_pole)
|
||||
local compound_entity = global.compound_entities["bi-bio-garden"]
|
||||
local compound_entity = storage.compound_entities["bi-bio-garden"]
|
||||
--~ local pole_type = "electric-pole"
|
||||
--~ local pole = global[compound_entity.tab][base.unit_number] and
|
||||
--~ global[compound_entity.tab][base.unit_number][pole_type] or
|
||||
--~ local pole = storage[compound_entity.tab][base.unit_number] and
|
||||
--~ storage[compound_entity.tab][base.unit_number][pole_type] or
|
||||
--~ new_pole
|
||||
local pole = global[compound_entity.tab][base.unit_number] and
|
||||
global[compound_entity.tab][base.unit_number].pole or
|
||||
local pole = storage[compound_entity.tab][base.unit_number] and
|
||||
storage[compound_entity.tab][base.unit_number].pole or
|
||||
new_pole
|
||||
|
||||
--~ if pole and pole.valid then
|
||||
--~ local wire_reach = game.entity_prototypes[compound_entity.hidden[pole_type]] and
|
||||
--~ game.entity_prototypes[compound_entity.hidden[pole_type]].max_wire_distance
|
||||
--~ local wire_reach = prototypes.entity[compound_entity.hidden[pole_type]] and
|
||||
--~ prototypes.entity[compound_entity.hidden[pole_type]].max_wire_distance
|
||||
if pole and pole.valid and compound_entity.hidden and
|
||||
compound_entity.hidden.pole and
|
||||
compound_entity.hidden.pole.name then
|
||||
local wire_reach = game.entity_prototypes[compound_entity.hidden.pole.name] and
|
||||
game.entity_prototypes[compound_entity.hidden.pole.name].max_wire_distance
|
||||
local wire_reach = prototypes.entity[compound_entity.hidden.pole.name] and
|
||||
prototypes.entity[compound_entity.hidden.pole.name].max_wire_distance
|
||||
if not wire_reach then
|
||||
error("Prototype for hidden pole of Bio gardens doesn't exist!")
|
||||
end
|
||||
|
|
@ -758,14 +758,14 @@ common.writeDebug("Connected pole %g to %s %g: %s",
|
|||
--~ -- Connect hidden poles to other poles that may be in reach.
|
||||
--~ common.garden_pole_connectors = common.garden_pole_connectors and next() or
|
||||
--~ common.get_garden_pole_connectors()
|
||||
--~ common.show("Poles hidden bio-garden poles may connect to", global.mod_settings.garden_pole_connectors)
|
||||
--~ common.show("Poles hidden bio-garden poles may connect to", storage.mod_settings.garden_pole_connectors)
|
||||
|
||||
-- Look for other poles around this one
|
||||
neighbours = pole.surface.find_entities_filtered({
|
||||
position = pole.position,
|
||||
radius = wire_reach,
|
||||
type = "electric-pole",
|
||||
name = global.mod_settings.garden_pole_connectors,
|
||||
name = storage.mod_settings.garden_pole_connectors,
|
||||
})
|
||||
common.writeDebug("Pole %g has %s neighbours", {pole.unit_number, #neighbours})
|
||||
for n, neighbour in pairs(neighbours or{}) do
|
||||
|
|
@ -785,7 +785,7 @@ common.writeDebug("Connected pole %g to neighbour %s (%g): %s",
|
|||
common.connect_power_rail = function(base, new_pole)
|
||||
--~ local pole_type = "electric-pole"
|
||||
|
||||
local pole = global.bi_power_rail_table[base.unit_number].pole or new_pole
|
||||
local pole = storage.bi_power_rail_table[base.unit_number].pole or new_pole
|
||||
if pole and pole.valid then
|
||||
-- Remove all copper wires from new pole
|
||||
pole.disconnect_neighbour()
|
||||
|
|
@ -806,7 +806,7 @@ common.writeDebug("Rail %s of %s (%s): %s (%s)", {direction, base.name, base.uni
|
|||
|
||||
-- Only make a connection if found rail is a powered rail
|
||||
-- (We'll know it's the right type if we find it in our table!)
|
||||
neighbour = neighbour and neighbour.valid and global.bi_power_rail_table[neighbour.unit_number]
|
||||
neighbour = neighbour and neighbour.valid and storage.bi_power_rail_table[neighbour.unit_number]
|
||||
if neighbour and neighbour.pole and neighbour.pole.valid then
|
||||
pole.connect_neighbour(neighbour.pole)
|
||||
common.writeDebug("Connected poles!")
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ end
|
|||
local function get_bi_trees()
|
||||
local list = {}
|
||||
|
||||
local trees = game.get_filtered_entity_prototypes({{filter = "type", type = "tree"}})
|
||||
local trees = prototypes.get_entity_filtered({{filter = "type", type = "tree"}})
|
||||
for tree_name, tree in pairs(trees) do
|
||||
if tree_name:match("^bio%-tree%-.+%-%d$") then
|
||||
BioInd.show("Found matching tree", tree_name)
|
||||
|
|
@ -70,7 +70,7 @@ local tile_patterns = {
|
|||
local function get_fixed_tiles()
|
||||
local list = {}
|
||||
|
||||
for tile_name, tile in pairs(game.tile_prototypes) do
|
||||
for tile_name, tile in pairs(prototypes.tile) do
|
||||
for p, pattern in ipairs(tile_patterns) do
|
||||
if tile_name:match(pattern) then
|
||||
BioInd.show("Found matching tile", tile_name)
|
||||
|
|
@ -89,7 +89,7 @@ end
|
|||
local function get_arboretum_recipes()
|
||||
local list = {}
|
||||
|
||||
local recipes = game.recipe_prototypes
|
||||
local recipes = prototypes.recipe
|
||||
local name
|
||||
|
||||
for i = 1, 5 do
|
||||
|
|
@ -119,40 +119,40 @@ BioInd.writeDebug("Entered init!")
|
|||
game.check_prototype_translations()
|
||||
end
|
||||
|
||||
global = global or {}
|
||||
storage = storage or {}
|
||||
|
||||
--------------------------------------------------------------------
|
||||
-- Settings
|
||||
--------------------------------------------------------------------
|
||||
-- Global table for storing the last state of certain mod settings
|
||||
global.mod_settings = global.mod_settings or {}
|
||||
storage.mod_settings = storage.mod_settings or {}
|
||||
if BioInd.get_startup_setting("BI_Easy_Bio_Gardens") then
|
||||
global.mod_settings.garden_pole_connectors = BioInd.get_garden_pole_connectors()
|
||||
storage.mod_settings.garden_pole_connectors = BioInd.get_garden_pole_connectors()
|
||||
else
|
||||
global.mod_settings.garden_pole_connectors = nil
|
||||
storage.mod_settings.garden_pole_connectors = nil
|
||||
end
|
||||
|
||||
-- Global table for storing the data of compound entities. They may change between
|
||||
-- saves (e.g. Bio gardens only need hidden poles when the "Easy gardens" setting
|
||||
-- is active).
|
||||
--~ global.compound_entities = global.compound_entities or BioInd.compound_entities
|
||||
global.compound_entities = BioInd.rebuild_compound_entity_list()
|
||||
--~ storage.compound_entities = storage.compound_entities or BioInd.compound_entities
|
||||
storage.compound_entities = BioInd.rebuild_compound_entity_list()
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
-- Tree stuff!
|
||||
--------------------------------------------------------------------
|
||||
global.bi = global.bi or {}
|
||||
global.bi.tree_growing = global.bi.tree_growing or {}
|
||||
storage.bi = storage.bi or {}
|
||||
storage.bi.tree_growing = storage.bi.tree_growing or {}
|
||||
for i = 1, 4 do
|
||||
global.bi["tree_growing_stage_" .. i] = global.bi["tree_growing_stage_" .. i] or {}
|
||||
storage.bi["tree_growing_stage_" .. i] = storage.bi["tree_growing_stage_" .. i] or {}
|
||||
end
|
||||
|
||||
-- List of tree prototypes created by BI
|
||||
global.bi.trees = get_bi_trees()
|
||||
storage.bi.trees = get_bi_trees()
|
||||
|
||||
-- List of tile prototypes that can't be fertilized
|
||||
global.bi.barren_tiles = get_fixed_tiles()
|
||||
storage.bi.barren_tiles = get_fixed_tiles()
|
||||
|
||||
--------------------------------------------------------------------
|
||||
-- Compound entities
|
||||
|
|
@ -160,7 +160,7 @@ BioInd.writeDebug("Entered init!")
|
|||
-- Check what global tables we need for compound entities
|
||||
local compound_entity_tables = {}
|
||||
--~ for compound, compound_data in pairs(BioInd.compound_entities) do
|
||||
for compound, compound_data in pairs(global.compound_entities) do
|
||||
for compound, compound_data in pairs(storage.compound_entities) do
|
||||
-- BioInd.compound_entities contains entries that point to the same table
|
||||
-- (e.g. straight/curved rails, or overlay entities), so we just overwrite
|
||||
-- them to remove duplicates
|
||||
|
|
@ -172,37 +172,37 @@ BioInd.show("Need to check these tables in global", compound_entity_tables)
|
|||
local result
|
||||
for compound_tab, compound_name in pairs(compound_entity_tables) do
|
||||
-- Init table
|
||||
global[compound_tab] = global[compound_tab] or {}
|
||||
BioInd.writeDebug("Initialized global[%s] (%s entities stored)",
|
||||
{compound_name, table_size(global[compound_tab])})
|
||||
storage[compound_tab] = storage[compound_tab] or {}
|
||||
BioInd.writeDebug("Initialized storage[%s] (%s entities stored)",
|
||||
{compound_name, table_size(storage[compound_tab])})
|
||||
-- If this compound entity requires additional tables in global, initialize
|
||||
-- them now!
|
||||
local related_tables = global.compound_entities[compound_name].add_global_tables
|
||||
local related_tables = storage.compound_entities[compound_name].add_global_tables
|
||||
if related_tables then
|
||||
for t, tab in ipairs(related_tables or {}) do
|
||||
global[tab] = global[tab] or {}
|
||||
BioInd.writeDebug("Initialized global[%s] (%s values)", {tab, table_size(global[tab])})
|
||||
storage[tab] = storage[tab] or {}
|
||||
BioInd.writeDebug("Initialized storage[%s] (%s values)", {tab, table_size(storage[tab])})
|
||||
end
|
||||
end
|
||||
-- If this compound entity requires additional values in global, initialize
|
||||
-- them now!
|
||||
local related_vars = global.compound_entities[compound_name].add_global_values
|
||||
local related_vars = storage.compound_entities[compound_name].add_global_values
|
||||
if related_vars then
|
||||
for var_name, value in pairs(related_vars or {}) do
|
||||
global[var_name] = global[var_name] or value
|
||||
BioInd.writeDebug("Set global[%s] to %s", {var_name, global[var_name]})
|
||||
storage[var_name] = storage[var_name] or value
|
||||
BioInd.writeDebug("Set storage[%s] to %s", {var_name, storage[var_name]})
|
||||
end
|
||||
end
|
||||
|
||||
-- Clean up global tables (We can skip this for empty tables!)
|
||||
if next(global[compound_tab]) then
|
||||
if next(storage[compound_tab]) then
|
||||
-- Remove invalid entities
|
||||
result = BioInd.clean_global_compounds_table(compound_name)
|
||||
BioInd.writeDebug("Removed %s invalid entries from global[%s]!",
|
||||
BioInd.writeDebug("Removed %s invalid entries from storage[%s]!",
|
||||
{result, compound_tab})
|
||||
-- Restore missing hidden entities
|
||||
result = BioInd.restore_missing_entities(compound_name)
|
||||
BioInd.writeDebug("Checked %s compound entities and restored %s missing hidden entries for global[\"%s\"]!",
|
||||
BioInd.writeDebug("Checked %s compound entities and restored %s missing hidden entries for storage[\"%s\"]!",
|
||||
{result.checked, result.restored, compound_tab})
|
||||
end
|
||||
end
|
||||
|
|
@ -215,9 +215,9 @@ BioInd.show("Need to check these tables in global", compound_entity_tables)
|
|||
--------------------------------------------------------------------
|
||||
-- Musk floor
|
||||
--------------------------------------------------------------------
|
||||
global.bi_musk_floor_table = global.bi_musk_floor_table or {}
|
||||
global.bi_musk_floor_table.tiles = global.bi_musk_floor_table.tiles or {}
|
||||
global.bi_musk_floor_table.forces = global.bi_musk_floor_table.forces or {}
|
||||
storage.bi_musk_floor_table = storage.bi_musk_floor_table or {}
|
||||
storage.bi_musk_floor_table.tiles = storage.bi_musk_floor_table.tiles or {}
|
||||
storage.bi_musk_floor_table.forces = storage.bi_musk_floor_table.forces or {}
|
||||
|
||||
|
||||
|
||||
|
|
@ -225,17 +225,17 @@ BioInd.show("Need to check these tables in global", compound_entity_tables)
|
|||
-- Arboretum
|
||||
--------------------------------------------------------------------
|
||||
-- Global table for arboretum radars
|
||||
global.bi_arboretum_radar_table = global.bi_arboretum_radar_table or {}
|
||||
storage.bi_arboretum_radar_table = storage.bi_arboretum_radar_table or {}
|
||||
|
||||
-- Global table of ingredients for terraformer recipes
|
||||
global.bi_arboretum_recipe_table = get_arboretum_recipes()
|
||||
storage.bi_arboretum_recipe_table = get_arboretum_recipes()
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
-- Compatibility with other mods
|
||||
--------------------------------------------------------------------
|
||||
global.compatible = global.compatible or {}
|
||||
global.compatible.AlienBiomes = BioInd.AB_tiles()
|
||||
storage.compatible = storage.compatible or {}
|
||||
storage.compatible.AlienBiomes = BioInd.AB_tiles()
|
||||
|
||||
|
||||
-- enable researched recipes
|
||||
|
|
@ -279,11 +279,11 @@ BioInd.writeDebug("On Configuration changed: %s", {ConfigurationChangedData})
|
|||
-- need to make sure that the lists of growing trees don't contain removed tree
|
||||
-- prototypes! (This fix is needed when "Alien Biomes" has been removed; it should
|
||||
-- work with all other mods that create trees as well.)
|
||||
local trees = global.bi.trees
|
||||
local trees = storage.bi.trees
|
||||
local tab
|
||||
-- Growing stages
|
||||
for i = 1, 4 do
|
||||
tab = global.bi["tree_growing_stage_" .. i]
|
||||
tab = storage.bi["tree_growing_stage_" .. i]
|
||||
BioInd.writeDebug("Number of trees in growing stage %s: %s", {i, table_size(tab)})
|
||||
--~ for t, tree in pairs(tab) do
|
||||
--~ if not trees[tree.tree_name] then
|
||||
|
|
@ -352,7 +352,7 @@ Event.register(defines.events.on_trigger_created_entity, function(event)
|
|||
--~ seed_planted_trigger(event)
|
||||
BioInd.writeDebug("Seed Bomb Activated - Standard")
|
||||
local currTile = surface.get_tile(position).name
|
||||
if global.bi.barren_tiles[currTile] then
|
||||
if storage.bi.barren_tiles[currTile] then
|
||||
BioInd.writeDebug("Can't fertilize %s!", {currTile})
|
||||
else
|
||||
BioInd.writeDebug("Using fertilizer!")
|
||||
|
|
@ -369,7 +369,7 @@ Event.register(defines.events.on_trigger_created_entity, function(event)
|
|||
--~ seed_planted_trigger(event)
|
||||
BioInd.writeDebug("Seed Bomb Activated - Advanced")
|
||||
local currTile = surface.get_tile(position).name
|
||||
if global.bi.barren_tiles[currTile] then
|
||||
if storage.bi.barren_tiles[currTile] then
|
||||
BioInd.writeDebug("Can't fertilize %s!", {currTile})
|
||||
else
|
||||
BioInd.writeDebug("Using fertilizer!")
|
||||
|
|
@ -406,7 +406,7 @@ local function On_Built(event)
|
|||
|
||||
BioInd.show("Built entity", BioInd.print_name_id(entity))
|
||||
|
||||
local base_entry = global.compound_entities[entity.name]
|
||||
local base_entry = storage.compound_entities[entity.name]
|
||||
local base = base_entry and entity
|
||||
|
||||
-- We've found a compound entity!
|
||||
|
|
@ -448,7 +448,7 @@ BioInd.show("base_entry.optional", base_entry.optional)
|
|||
BioInd.writeDebug("Second pass -- creating hidden entities!")
|
||||
BioInd.show("base_entry", base_entry)
|
||||
|
||||
BioInd.writeDebug("global[%s]: %s", {base_entry.tab, global[base_entry.tab]})
|
||||
BioInd.writeDebug("storage[%s]: %s", {base_entry.tab, storage[base_entry.tab]})
|
||||
BioInd.show("base.name", base.name)
|
||||
BioInd.show("base.unit_number", base.unit_number)
|
||||
BioInd.show("hidden_entities", hidden_entities)
|
||||
|
|
@ -456,9 +456,9 @@ BioInd.show("hidden_entities", hidden_entities)
|
|||
-- We must call create_entities even if there are no hidden entities (e.g. if
|
||||
-- the "Easy Gardens" setting is disabled and no hidden poles are required)
|
||||
-- because the compound entity gets registered there!
|
||||
BioInd.create_entities(global[base_entry.tab], base, hidden_entities)
|
||||
BioInd.create_entities(storage[base_entry.tab], base, hidden_entities)
|
||||
BioInd.writeDebug("Stored %s in table: %s",
|
||||
{BioInd.print_name_id(base), global[base_entry.tab][base.unit_number]})
|
||||
{BioInd.print_name_id(base), storage[base_entry.tab][base.unit_number]})
|
||||
end
|
||||
|
||||
-- The built entity isn't one of our compound entities.
|
||||
|
|
@ -480,9 +480,9 @@ BioInd.show("Base entity", BioInd.print_name_id(base))
|
|||
-- Arboretum radar -- we need to add it to the table!
|
||||
if entity.type == "radar" and
|
||||
entity.name == entities["bi-arboretum-area"].hidden[h_key].name and base then
|
||||
global.bi_arboretum_radar_table[entity.unit_number] = base.unit_number
|
||||
storage.bi_arboretum_radar_table[entity.unit_number] = base.unit_number
|
||||
entity.backer_name = ""
|
||||
BioInd.writeDebug("Added %s to global.bi_arboretum_radar_table", {BioInd.print_name_id(entity)})
|
||||
BioInd.writeDebug("Added %s to storage.bi_arboretum_radar_table", {BioInd.print_name_id(entity)})
|
||||
|
||||
-- Electric poles -- we need to take care that they don't hook up to hidden poles!
|
||||
elseif entity.type == "electric-pole" then
|
||||
|
|
@ -562,15 +562,15 @@ BioInd.writeDebug("Entered function On_Pre_Remove(%s)", {event})
|
|||
end
|
||||
|
||||
--~ local compound_entity = BioInd.compound_entities[entity.name]
|
||||
local compound_entity = global.compound_entities[entity.name]
|
||||
local base_entry = compound_entity and global[compound_entity.tab][entity.unit_number]
|
||||
local compound_entity = storage.compound_entities[entity.name]
|
||||
local base_entry = compound_entity and storage[compound_entity.tab][entity.unit_number]
|
||||
BioInd.show("entity.name", entity.name)
|
||||
BioInd.show("entity.unit_number", entity.unit_number)
|
||||
|
||||
BioInd.show("compound_entity", compound_entity)
|
||||
BioInd.show("base_entry", base_entry)
|
||||
BioInd.show("compound_entity.tab", compound_entity and compound_entity.tab or "nil")
|
||||
BioInd.writeDebug("global[%s]: %s", {compound_entity and compound_entity.tab or "nil", compound_entity and global[compound_entity.tab] or "nil"})
|
||||
BioInd.writeDebug("storage[%s]: %s", {compound_entity and compound_entity.tab or "nil", compound_entity and storage[compound_entity.tab] or "nil"})
|
||||
|
||||
-- Found a compound entity from our list!
|
||||
if base_entry then
|
||||
|
|
@ -579,8 +579,8 @@ BioInd.writeDebug("Found compound entity %s",
|
|||
|
||||
-- Arboretum: Need to separately remove the entry from the radar table
|
||||
if entity.name == "bi-arboretum" and base_entry.radar and base_entry.radar.valid then
|
||||
global.bi_arboretum_radar_table[base_entry.radar.unit_number] = nil
|
||||
BioInd.show("Removed arboretum radar! Table", global.bi_arboretum_radar_table)
|
||||
storage.bi_arboretum_radar_table[base_entry.radar.unit_number] = nil
|
||||
BioInd.show("Removed arboretum radar! Table", storage.bi_arboretum_radar_table)
|
||||
end
|
||||
|
||||
-- Power rails: Connections must be explicitely removed, otherwise the poles
|
||||
|
|
@ -603,7 +603,7 @@ BioInd.writeDebug("Removing hidden entity %s", {BioInd.print_name_id(base_entry[
|
|||
BioInd.remove_entity(base_entry[hidden])
|
||||
base_entry[hidden] = nil
|
||||
end
|
||||
global[compound_entity.tab][entity.unit_number] = nil
|
||||
storage[compound_entity.tab][entity.unit_number] = nil
|
||||
|
||||
-- Rail-to-power: Connections must be explicitely removed, otherwise the poles
|
||||
-- from the different rail tracks hooked up to this connector will automatically
|
||||
|
|
@ -616,16 +616,16 @@ BioInd.writeDebug("Removing hidden entity %s", {BioInd.print_name_id(base_entry[
|
|||
-- Removed seedling
|
||||
elseif entity.name == "seedling" then
|
||||
BioInd.writeDebug("Seedling has been removed")
|
||||
remove_plants(entity.position, global.bi.tree_growing)
|
||||
remove_plants(entity.position, storage.bi.tree_growing)
|
||||
|
||||
-- Removed tree
|
||||
elseif entity.type == "tree" and global.bi.trees[entity.name] then
|
||||
elseif entity.type == "tree" and storage.bi.trees[entity.name] then
|
||||
BioInd.show("Removed tree", entity.name)
|
||||
|
||||
local tree_stage = entity.name:match('^.+%-(%d)$')
|
||||
BioInd.writeDebug("Removed tree %s (grow stage: %s)", {entity.name, tree_stage or nil})
|
||||
if tree_stage then
|
||||
remove_plants(entity.position, global.bi["tree_growing_stage_" .. tree_stage])
|
||||
remove_plants(entity.position, storage.bi["tree_growing_stage_" .. tree_stage])
|
||||
else
|
||||
error(string.format("Tree %s does not have a valid tree_stage: %s", entity.name, tree_stage or "nil"))
|
||||
end
|
||||
|
|
@ -649,11 +649,11 @@ local function On_Damage(event)
|
|||
|
||||
-- Base was damaged: Find the radar associated with it!
|
||||
if entity.name == arb then
|
||||
associated = global.bi_arboretum_table[entity.unit_number].radar
|
||||
associated = storage.bi_arboretum_table[entity.unit_number].radar
|
||||
-- Radar was damaged: Find the base entity!
|
||||
elseif entity.name == global.compound_entities[arb].hidden.radar.name then
|
||||
local base_id = global.bi_arboretum_radar_table[entity.unit_number]
|
||||
associated = global.bi_arboretum_table[base_id].base
|
||||
elseif entity.name == storage.compound_entities[arb].hidden.radar.name then
|
||||
local base_id = storage.bi_arboretum_radar_table[entity.unit_number]
|
||||
associated = storage.bi_arboretum_table[base_id].base
|
||||
end
|
||||
|
||||
if associated and associated.valid then
|
||||
|
|
@ -679,10 +679,10 @@ BioInd.writeDebug("Entered function %s(%s)", {f_name, event})
|
|||
|
||||
if
|
||||
-- Table checks
|
||||
global.compound_entities[entity.name] or
|
||||
global.bi.trees[entity.name] or
|
||||
storage.compound_entities[entity.name] or
|
||||
storage.bi.trees[entity.name] or
|
||||
-- Entity checks
|
||||
entity.name == global.compound_entities["bi-arboretum"].hidden.radar.name or
|
||||
entity.name == storage.compound_entities["bi-arboretum"].hidden.radar.name or
|
||||
entity.name == "bi-power-to-rail-pole" or
|
||||
entity.name == "seedling" then
|
||||
|
||||
|
|
@ -704,9 +704,9 @@ local function On_Sector_Scanned(event)
|
|||
BioInd.writeDebug("Entered function %s(%s)", {f_name, event})
|
||||
|
||||
---- Each time a Arboretum-Radar scans a sector ----
|
||||
local arboretum = global.bi_arboretum_radar_table[event.radar.unit_number]
|
||||
local arboretum = storage.bi_arboretum_radar_table[event.radar.unit_number]
|
||||
if arboretum then
|
||||
Get_Arboretum_Recipe(global.bi_arboretum_table[arboretum], event)
|
||||
Get_Arboretum_Recipe(storage.bi_arboretum_table[arboretum], event)
|
||||
end
|
||||
end
|
||||
|
||||
|
|
@ -740,21 +740,21 @@ BioInd.show("Removing", o.name)
|
|||
end
|
||||
|
||||
-- Remove tile from global tables
|
||||
local force_name = global.bi_musk_floor_table.tiles and
|
||||
global.bi_musk_floor_table.tiles[x] and
|
||||
global.bi_musk_floor_table.tiles[x][y]
|
||||
local force_name = storage.bi_musk_floor_table.tiles and
|
||||
storage.bi_musk_floor_table.tiles[x] and
|
||||
storage.bi_musk_floor_table.tiles[x][y]
|
||||
if force_name then
|
||||
BioInd.writeDebug("Removing Musk floor tile from tables!")
|
||||
global.bi_musk_floor_table.tiles[x][y] = nil
|
||||
if not next(global.bi_musk_floor_table.tiles[x]) then
|
||||
global.bi_musk_floor_table.tiles[x] = nil
|
||||
storage.bi_musk_floor_table.tiles[x][y] = nil
|
||||
if not next(storage.bi_musk_floor_table.tiles[x]) then
|
||||
storage.bi_musk_floor_table.tiles[x] = nil
|
||||
end
|
||||
|
||||
if global.bi_musk_floor_table.forces[force_name] and
|
||||
global.bi_musk_floor_table.forces[force_name][x] then
|
||||
global.bi_musk_floor_table.forces[force_name][x][y] = nil
|
||||
if not next(global.bi_musk_floor_table.forces[force_name][x]) then
|
||||
global.bi_musk_floor_table.forces[force_name][x] = nil
|
||||
if storage.bi_musk_floor_table.forces[force_name] and
|
||||
storage.bi_musk_floor_table.forces[force_name][x] then
|
||||
storage.bi_musk_floor_table.forces[force_name][x][y] = nil
|
||||
if not next(storage.bi_musk_floor_table.forces[force_name][x]) then
|
||||
storage.bi_musk_floor_table.forces[force_name][x] = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -783,12 +783,12 @@ local function place_musk_floor(force, position, surface)
|
|||
end
|
||||
|
||||
-- Add to global tables!
|
||||
global.bi_musk_floor_table.tiles[x] = global.bi_musk_floor_table.tiles[x] or {}
|
||||
global.bi_musk_floor_table.tiles[x][y] = force
|
||||
storage.bi_musk_floor_table.tiles[x] = storage.bi_musk_floor_table.tiles[x] or {}
|
||||
storage.bi_musk_floor_table.tiles[x][y] = force
|
||||
|
||||
global.bi_musk_floor_table.forces[force] = global.bi_musk_floor_table.forces[force] or {}
|
||||
global.bi_musk_floor_table.forces[force][x] = global.bi_musk_floor_table.forces[force][x] or {}
|
||||
global.bi_musk_floor_table.forces[force][x][y] = true
|
||||
storage.bi_musk_floor_table.forces[force] = storage.bi_musk_floor_table.forces[force] or {}
|
||||
storage.bi_musk_floor_table.forces[force][x] = storage.bi_musk_floor_table.forces[force][x] or {}
|
||||
storage.bi_musk_floor_table.forces[force][x][y] = true
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------
|
||||
|
|
@ -849,12 +849,12 @@ BioInd.show("index", index)
|
|||
BioInd.show("t.old_tile.name", t.old_tile.name)
|
||||
|
||||
-- We want to restore removed tiles if nothing is supposed to grow on them!
|
||||
if global.bi.barren_tiles[t.old_tile.name] then
|
||||
if storage.bi.barren_tiles[t.old_tile.name] then
|
||||
BioInd.writeDebug("%s was used on forbidden ground (%s)!", {item.name, t.old_tile.name})
|
||||
restore_tiles[#restore_tiles + 1] = {name = t.old_tile.name, position = t.position}
|
||||
|
||||
-- Is that tile minable?
|
||||
products = global.bi.barren_tiles[t.old_tile.name]
|
||||
products = storage.bi.barren_tiles[t.old_tile.name]
|
||||
if type(products) == "table" then
|
||||
--~ for p, product in ipairs(products) do
|
||||
--~ if player then
|
||||
|
|
@ -897,10 +897,10 @@ BioInd.show("restore_tiles", restore_tiles)
|
|||
local removed_tiles = {}
|
||||
for index, t in pairs(old_tiles or {tile}) do
|
||||
position = BioInd.normalize_position(t.position)
|
||||
test = global.bi_musk_floor_table and
|
||||
global.bi_musk_floor_table.tiles and
|
||||
global.bi_musk_floor_table.tiles[position.x] and
|
||||
global.bi_musk_floor_table.tiles[position.x][position.y]
|
||||
test = storage.bi_musk_floor_table and
|
||||
storage.bi_musk_floor_table.tiles and
|
||||
storage.bi_musk_floor_table.tiles[position.x] and
|
||||
storage.bi_musk_floor_table.tiles[position.x][position.y]
|
||||
if test then
|
||||
removed_tiles[#removed_tiles + 1] = {
|
||||
old_tile = {name = "bi-solar-mat"},
|
||||
|
|
@ -937,8 +937,8 @@ local function Tile_Changed(event)
|
|||
for t, tile in ipairs(event.tiles) do
|
||||
BioInd.show("t", t)
|
||||
pos = BioInd.normalize_position(tile.position)
|
||||
tile_force = global.bi_musk_floor_table.tiles[pos.x] and
|
||||
global.bi_musk_floor_table.tiles[pos.x][pos.y]
|
||||
tile_force = storage.bi_musk_floor_table.tiles[pos.x] and
|
||||
storage.bi_musk_floor_table.tiles[pos.x][pos.y]
|
||||
--~ -- Fall back to MuskForceName if it is available
|
||||
--~ UseMuskForce and MuskForceName or
|
||||
--~ -- Fall back to "neutral"
|
||||
|
|
@ -1059,8 +1059,8 @@ Event.register(defines.events.on_entity_damaged, On_Damage, function(event)
|
|||
-- Ignore damage without effect (invulnerable/resistant entities)
|
||||
if event.final_damage_amount ~= 0 and
|
||||
-- Terraformer/Terraformer radar was damaged
|
||||
(global.bi_arboretum_table[entity.unit_number] or
|
||||
global.bi_arboretum_radar_table[entity.unit_number]) then
|
||||
(storage.bi_arboretum_table[entity.unit_number] or
|
||||
storage.bi_arboretum_radar_table[entity.unit_number]) then
|
||||
return true
|
||||
end
|
||||
end)
|
||||
|
|
@ -1087,7 +1087,7 @@ setmetatable(_ENV, {
|
|||
.. serpent.line{key = key or '<nil>', value = value or '<nil>'} .. '\n')
|
||||
end,
|
||||
__index = function (self, key) --locked_global_read
|
||||
if not (key == "game" or key == "mods") then
|
||||
if not (key == "game" or key == "mods" or key == "storage") then
|
||||
error('\n\n[ER Global Lock] Forbidden global *read*:\n'
|
||||
.. serpent.line{key = key or '<nil>'} .. '\n')
|
||||
end
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ end
|
|||
-- Check that all ingredients are available!
|
||||
local function check_ingredients(arboretum)
|
||||
local recipe = arboretum.get_recipe()
|
||||
local need = recipe and global.bi_arboretum_recipe_table[recipe.name]
|
||||
local need = recipe and storage.bi_arboretum_recipe_table[recipe.name]
|
||||
|
||||
local function check(need, have)
|
||||
for name, amount in pairs(need or {}) do
|
||||
|
|
@ -111,7 +111,7 @@ function Get_Arboretum_Recipe(ArboretumTable, event)
|
|||
|
||||
-- 'AlienBiomes' is a bool value -- we don't want to read it again if it's false,
|
||||
-- but only if it hasn't been set yet!
|
||||
AB = global.compatible.AlienBiomes
|
||||
AB = storage.compatible.AlienBiomes
|
||||
--~ terrain_name_g1 = terrain_name_g1 or (AB and "vegetation-green-grass-1" or "grass-1")
|
||||
--~ terrain_name_g3 = terrain_name_g3 or (AB and "vegetation-green-grass-3" or "grass-3")
|
||||
terrain_name_g1 = terrain_name_g1 or (AB and "vegetation-green-grass-1" or "grass-1")
|
||||
|
|
|
|||
|
|
@ -317,7 +317,7 @@ BioInd.show("seedbomb", seedbomb)
|
|||
surface = surface,
|
||||
seed_bomb = seedbomb
|
||||
}
|
||||
plant_tree(global.bi.tree_growing, tree_data, false)
|
||||
plant_tree(storage.bi.tree_growing, tree_data, false)
|
||||
end
|
||||
|
||||
function seed_planted(event)
|
||||
|
|
@ -449,8 +449,8 @@ BioInd.show(growth_chance.." <= ("..fertility.." + 5)", growth_chance <= (fertil
|
|||
BioInd.show("grow_time", grow_time)
|
||||
|
||||
local stage_1_tree_name = "bio-tree-"..tree_name.."-1"
|
||||
if not (game.item_prototypes[stage_1_tree_name] or
|
||||
game.entity_prototypes[stage_1_tree_name]) then
|
||||
if not (prototypes.item[stage_1_tree_name] or
|
||||
prototypes.entity[stage_1_tree_name]) then
|
||||
stage_1_tree_name = tree_name
|
||||
end
|
||||
BioInd.writeDebug("stage_1_tree_name: %s", {stage_1_tree_name})
|
||||
|
|
@ -462,7 +462,7 @@ BioInd.writeDebug("stage_1_tree_name: %s", {stage_1_tree_name})
|
|||
time = event.tick + grow_time,
|
||||
surface = surface
|
||||
}
|
||||
plant_tree(global.bi.tree_growing_stage_1, tree_data, true)
|
||||
plant_tree(storage.bi.tree_growing_stage_1, tree_data, true)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -587,8 +587,8 @@ BioInd.writeDebug("Entered function Grow_tree_stage(%s, %s)", {stage_table, stag
|
|||
local fertility, key = f.fertility, f.key
|
||||
|
||||
local next_stage_tree_name = "bio-tree-"..final_tree.."-"..next_stage
|
||||
if not (game.item_prototypes[next_stage_tree_name] or
|
||||
game.entity_prototypes[next_stage_tree_name]) then
|
||||
if not (prototypes.item[next_stage_tree_name] or
|
||||
prototypes.entity[next_stage_tree_name]) then
|
||||
next_stage_tree_name = final_tree
|
||||
BioInd.writeDebug("Next stage %g: Prototype did not exist", {next_stage})
|
||||
else
|
||||
|
|
@ -622,7 +622,7 @@ BioInd.writeDebug("Entered function Grow_tree_stage(%s, %s)", {stage_table, stag
|
|||
time = time_planted + grow_time,
|
||||
surface = surface
|
||||
}
|
||||
plant_tree(global.bi["tree_growing_stage_"..next_stage], tree_data, true)
|
||||
plant_tree(storage.bi["tree_growing_stage_"..next_stage], tree_data, true)
|
||||
end
|
||||
end
|
||||
|
||||
|
|
@ -636,32 +636,32 @@ end
|
|||
---- Growing Tree
|
||||
--Event.register(-12, function(event)
|
||||
Event.register(defines.events.on_tick, function(event)
|
||||
if global.bi.tree_growing_stage_1 == nil then
|
||||
if storage.bi.tree_growing_stage_1 == nil then
|
||||
for i = 1, 4 do
|
||||
global.bi["tree_growing_stage_"..i] = global.bi["tree_growing_stage_"..i] or {}
|
||||
storage.bi["tree_growing_stage_"..i] = storage.bi["tree_growing_stage_"..i] or {}
|
||||
end
|
||||
end
|
||||
|
||||
local tick = event.tick
|
||||
|
||||
if global.bi.tree_growing[tick] then
|
||||
for t, tree_data in pairs(global.bi.tree_growing[tick]) do
|
||||
if storage.bi.tree_growing[tick] then
|
||||
for t, tree_data in pairs(storage.bi.tree_growing[tick]) do
|
||||
BioInd.writeDebug("Trying to move tree %s to first grow stage!", {t})
|
||||
Grow_tree_first_stage(tree_data, event)
|
||||
end
|
||||
BioInd.writeDebug("Removing global.bi.tree_growing[%s]!", {tick})
|
||||
global.bi.tree_growing[tick] = nil
|
||||
BioInd.writeDebug("Removing storage.bi.tree_growing[%s]!", {tick})
|
||||
storage.bi.tree_growing[tick] = nil
|
||||
end
|
||||
|
||||
local stage_table
|
||||
for stage = 1, 4 do
|
||||
stage_table = global.bi["tree_growing_stage_"..stage]
|
||||
stage_table = storage.bi["tree_growing_stage_"..stage]
|
||||
if stage_table[tick] then
|
||||
for t, tree_data in pairs(stage_table[tick]) do
|
||||
BioInd.writeDebug("Moving tree %s to next grow stage!", {t})
|
||||
Grow_tree_stage(tree_data, stage)
|
||||
end
|
||||
BioInd.writeDebug("Removing global.bi.tree_growing_stage_%s[%s]!",
|
||||
BioInd.writeDebug("Removing storage.bi.tree_growing_stage_%s[%s]!",
|
||||
{stage, tick})
|
||||
stage_table[tick] = nil
|
||||
end
|
||||
|
|
|
|||
|
|
@ -73,15 +73,15 @@ function ungroup(index_id, group_id)
|
|||
end
|
||||
-------------------------------------------------------------------
|
||||
function _init_group(index_id)
|
||||
if not global.group then
|
||||
global.group = {}
|
||||
if not storage.group then
|
||||
storage.group = {}
|
||||
end
|
||||
if not global.group.default then
|
||||
global.group.default = {}
|
||||
if not storage.group.default then
|
||||
storage.group.default = {}
|
||||
end
|
||||
if index_id and not global.group[index_id] then
|
||||
if index_id and not storage.group[index_id] then
|
||||
-- don't care if they name their group "default"
|
||||
global.group[index_id] = {}
|
||||
storage.group[index_id] = {}
|
||||
end
|
||||
end
|
||||
|
||||
|
|
@ -90,8 +90,8 @@ function _new_group(index_id)
|
|||
local group_id_r = nil
|
||||
|
||||
while group_id_r == nil do
|
||||
local group_id_x = "gid-" .. (group_id_n + #global.group[index_id])
|
||||
if global.group[index_id][group_id_x] then
|
||||
local group_id_x = "gid-" .. (group_id_n + #storage.group[index_id])
|
||||
if storage.group[index_id][group_id_x] then
|
||||
-- collision
|
||||
group_id_n = group_id_n + 1
|
||||
else
|
||||
|
|
@ -103,22 +103,22 @@ function _new_group(index_id)
|
|||
end
|
||||
|
||||
function _addto_group(index_id, group_id, member_id)
|
||||
if global.group[index_id] then
|
||||
if not global.group[index_id][group_id] then
|
||||
global.group[index_id][group_id] = {}
|
||||
if storage.group[index_id] then
|
||||
if not storage.group[index_id][group_id] then
|
||||
storage.group[index_id][group_id] = {}
|
||||
end
|
||||
end
|
||||
|
||||
table.insert(global.group[index_id][group_id], member_id)
|
||||
table.insert(storage.group[index_id][group_id], member_id)
|
||||
end
|
||||
|
||||
function _get_group(index_id, group_id)
|
||||
return global.group[index_id][group_id]
|
||||
return storage.group[index_id][group_id]
|
||||
end
|
||||
|
||||
function _of_group(index_id, member_id)
|
||||
--full scan
|
||||
for kx, vx in pairs(global.group[index_id]) do
|
||||
for kx, vx in pairs(storage.group[index_id]) do
|
||||
for ky, vy in pairs(vx) do
|
||||
if member_id == vy then
|
||||
return vx
|
||||
|
|
@ -129,7 +129,7 @@ function _of_group(index_id, member_id)
|
|||
end
|
||||
|
||||
function _clear_group(index_id, group_id)
|
||||
global.group[index_id][group_id] = nil
|
||||
storage.group[index_id][group_id] = nil
|
||||
end
|
||||
-------------------------------------------------------------------
|
||||
|
||||
|
|
|
|||
|
|
@ -169,20 +169,20 @@ end
|
|||
--~ data:extend({list})
|
||||
--[[
|
||||
Types of settings:
|
||||
• startup - game must be restarted if changed (such a setting may affect prototypes' changes)
|
||||
• runtime-global - per-world setting
|
||||
• runtime-per-user - per-user setting
|
||||
<EFBFBD> startup - game must be restarted if changed (such a setting may affect prototypes' changes)
|
||||
<EFBFBD> runtime-global - per-world setting
|
||||
<EFBFBD> runtime-per-user - per-user setting
|
||||
|
||||
Types of values:
|
||||
• bool-setting
|
||||
• double-setting
|
||||
• int-setting
|
||||
• string-setting
|
||||
<EFBFBD> bool-setting
|
||||
<EFBFBD> double-setting
|
||||
<EFBFBD> int-setting
|
||||
<EFBFBD> string-setting
|
||||
|
||||
Files being processed by the game:
|
||||
• settings.lua
|
||||
• settings-updates.lua
|
||||
• settings-final-fixes.lua
|
||||
<EFBFBD> settings.lua
|
||||
<EFBFBD> settings-updates.lua
|
||||
<EFBFBD> settings-final-fixes.lua
|
||||
|
||||
Using in DATA.lua:
|
||||
data:extend({
|
||||
|
|
@ -230,7 +230,7 @@ Using in CONTROL.lua and in other code for reading:
|
|||
event.player_index
|
||||
event.setting
|
||||
GET: settings.startup["setting-name"].value - current value of startup setting; can be used in DATA.lua
|
||||
GET: settings.global["setting-name"].value - current value of per-world setting
|
||||
GET: settings.storage["setting-name"].value - current value of per-world setting
|
||||
GET: set = settings.get_player_settings(LuaPlayer) - current values for per-player settings; then use set["setting-name"].value
|
||||
GET: settings.player - default values
|
||||
]]
|
||||
|
|
|
|||
|
|
@ -99,10 +99,10 @@ settings_changed.bio_garden = function()
|
|||
|
||||
-- Has this setting been changed since the last time the game was run?
|
||||
local current = BioInd.get_startup_setting("BI_Easy_Bio_Gardens")
|
||||
BioInd.show("Last state of BI_Easy_Bio_Gardens", global.mod_settings.BI_Easy_Bio_Gardens)
|
||||
BioInd.show("Last state of BI_Easy_Bio_Gardens", storage.mod_settings.BI_Easy_Bio_Gardens)
|
||||
BioInd.show("Current state of BI_Easy_Bio_Gardens", current)
|
||||
|
||||
if global.mod_settings.BI_Easy_Bio_Gardens ~= current then
|
||||
if storage.mod_settings.BI_Easy_Bio_Gardens ~= current then
|
||||
BioInd.writeDebug("Setting has been changed!")
|
||||
local pole, neighbours
|
||||
-- This is the unmodified table!
|
||||
|
|
@ -110,7 +110,7 @@ BioInd.writeDebug("Setting has been changed!")
|
|||
local hidden_entities = compound_entity.hidden
|
||||
|
||||
-- Check that all gardens are still valid
|
||||
for g, garden in pairs(global[compound_entity.tab]) do
|
||||
for g, garden in pairs(storage[compound_entity.tab]) do
|
||||
-- Base entity doesn't exist -- remove hidden entities!''
|
||||
if not (garden.base and garden.base.valid) then
|
||||
-- Remove all hidden entities!
|
||||
|
|
@ -122,7 +122,7 @@ BioInd.writeDebug("Removing hidden entity %s %s", {
|
|||
BioInd.remove_entity(garden[hidden])
|
||||
garden[hidden] = nil
|
||||
end
|
||||
global[compound_entity.tab][garden.entity.unit_number] = nil
|
||||
storage[compound_entity.tab][garden.entity.unit_number] = nil
|
||||
end
|
||||
end
|
||||
|
||||
|
|
@ -148,12 +148,12 @@ BioInd.writeDebug("Removing hidden entity %s %s", {
|
|||
-- Setting is on, so we need to create the hidden poles
|
||||
if current then
|
||||
BioInd.writeDebug("Need to create hidden poles for %s Bio Gardens!",
|
||||
{table_size(global.bi_bio_garden_table) })
|
||||
{table_size(storage.bi_bio_garden_table) })
|
||||
|
||||
-- Restore the list of hidden entities
|
||||
global.compound_entities["bi-bio-garden"] = BioInd.compound_entities["bi-bio-garden"]
|
||||
storage.compound_entities["bi-bio-garden"] = BioInd.compound_entities["bi-bio-garden"]
|
||||
local base
|
||||
for g, garden in pairs(global.bi_bio_garden_table or {}) do
|
||||
for g, garden in pairs(storage.bi_bio_garden_table or {}) do
|
||||
-- Make sure the base entity exists!
|
||||
base = garden.base
|
||||
pole = base and garden[pole_type]
|
||||
|
|
@ -168,7 +168,7 @@ BioInd.show("pole", pole)
|
|||
elseif base then
|
||||
-- Create hidden poles
|
||||
pole = BioInd.create_entities(
|
||||
global[compound_entity.tab],
|
||||
storage[compound_entity.tab],
|
||||
base,
|
||||
{pole = hidden_entities[pole_type].name}
|
||||
--~ base.position
|
||||
|
|
@ -176,11 +176,11 @@ BioInd.show("pole", pole)
|
|||
|
||||
-- Add the new pole to the table
|
||||
if pole then
|
||||
global[compound_entity.tab][base.unit_number][pole_type] = pole
|
||||
storage[compound_entity.tab][base.unit_number][pole_type] = pole
|
||||
BioInd.writeDebug("Stored %s %g in table: %s", {
|
||||
base.name,
|
||||
base.unit_number,
|
||||
global[compound_entity.tab][base.unit_number]
|
||||
storage[compound_entity.tab][base.unit_number]
|
||||
})
|
||||
end
|
||||
end
|
||||
|
|
@ -189,10 +189,10 @@ BioInd.show("pole", pole)
|
|||
-- Setting is off -- disconnect and remove hidden poles!
|
||||
else
|
||||
BioInd.writeDebug("%s Bio Gardens found -- try to disconnect hidden poles!",
|
||||
{table_size(global.bi_bio_garden_table) })
|
||||
{table_size(storage.bi_bio_garden_table) })
|
||||
-- Find hidden poles of registered gardens
|
||||
BioInd.show("global.bi_bio_garden_table", global.bi_bio_garden_table)
|
||||
for g, garden in pairs(global.bi_bio_garden_table or {}) do
|
||||
BioInd.show("storage.bi_bio_garden_table", storage.bi_bio_garden_table)
|
||||
for g, garden in pairs(storage.bi_bio_garden_table or {}) do
|
||||
if garden[pole_type] then
|
||||
-- Pole really exists: destroy the entity
|
||||
if garden[pole_type].valid then
|
||||
|
|
@ -212,8 +212,8 @@ BioInd.show("global.bi_bio_garden_table", global.bi_bio_garden_table)
|
|||
|
||||
-- We don't want to create hidden poles if the setting is off,
|
||||
-- so remove the pole from hidden entities!
|
||||
global.compound_entities["bi-bio-garden"].hidden[pole_type] = nil
|
||||
BioInd.show("global.compound_entities", global.compound_entities)
|
||||
storage.compound_entities["bi-bio-garden"].hidden[pole_type] = nil
|
||||
BioInd.show("storage.compound_entities", storage.compound_entities)
|
||||
end
|
||||
|
||||
-- Remove any hidden poles that are not associated with a garden
|
||||
|
|
@ -224,8 +224,8 @@ BioInd.show("global.compound_entities", global.compound_entities)
|
|||
end
|
||||
|
||||
-- Update setting!
|
||||
global.mod_settings.BI_Easy_Bio_Gardens = current
|
||||
BioInd.show("Updated setting to", global.mod_settings.BI_Easy_Bio_Gardens)
|
||||
storage.mod_settings.BI_Easy_Bio_Gardens = current
|
||||
BioInd.show("Updated setting to", storage.mod_settings.BI_Easy_Bio_Gardens)
|
||||
else
|
||||
BioInd.writeDebug("Nothing to do!")
|
||||
end
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue