From 447c47f0f393ffcbbcfe277482a8276569851abf Mon Sep 17 00:00:00 2001
From: Simon Brodtmann <github@accounts.brodtmann.info>
Date: Sat, 5 Jul 2025 22:25:02 +0200
Subject: [PATCH] Fix runtime scripts

---
 Bio_Industries_2/common.lua            |  84 ++++++------
 Bio_Industries_2/control.lua           | 178 ++++++++++++-------------
 Bio_Industries_2/control_arboretum.lua |   4 +-
 Bio_Industries_2/control_tree.lua      |  30 ++---
 Bio_Industries_2/libs/util_ext.lua     |  30 ++---
 Bio_Industries_2/settings.lua          |  22 +--
 Bio_Industries_2/settings_changed.lua  |  34 ++---
 7 files changed, 191 insertions(+), 191 deletions(-)

diff --git a/Bio_Industries_2/common.lua b/Bio_Industries_2/common.lua
index 2e9d10e..209d09d 100644
--- a/Bio_Industries_2/common.lua
+++ b/Bio_Industries_2/common.lua
@@ -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!")
diff --git a/Bio_Industries_2/control.lua b/Bio_Industries_2/control.lua
index adf83d2..523c8f5 100644
--- a/Bio_Industries_2/control.lua
+++ b/Bio_Industries_2/control.lua
@@ -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
diff --git a/Bio_Industries_2/control_arboretum.lua b/Bio_Industries_2/control_arboretum.lua
index f285157..490f851 100644
--- a/Bio_Industries_2/control_arboretum.lua
+++ b/Bio_Industries_2/control_arboretum.lua
@@ -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")
diff --git a/Bio_Industries_2/control_tree.lua b/Bio_Industries_2/control_tree.lua
index 74b9120..31660ff 100644
--- a/Bio_Industries_2/control_tree.lua
+++ b/Bio_Industries_2/control_tree.lua
@@ -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
diff --git a/Bio_Industries_2/libs/util_ext.lua b/Bio_Industries_2/libs/util_ext.lua
index d576fb6..be73d1a 100644
--- a/Bio_Industries_2/libs/util_ext.lua
+++ b/Bio_Industries_2/libs/util_ext.lua
@@ -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
 -------------------------------------------------------------------
 
diff --git a/Bio_Industries_2/settings.lua b/Bio_Industries_2/settings.lua
index 0dc8865..2d442bb 100644
--- a/Bio_Industries_2/settings.lua
+++ b/Bio_Industries_2/settings.lua
@@ -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
+        � 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
 
 Types of values:
-        • bool-setting
-        • double-setting
-        • int-setting
-        • string-setting
+        � bool-setting
+        � double-setting
+        � int-setting
+        � string-setting
 
 Files being processed by the game:
-        • settings.lua
-        • settings-updates.lua
-        • settings-final-fixes.lua
+        � settings.lua
+        � settings-updates.lua
+        � 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
 ]]
diff --git a/Bio_Industries_2/settings_changed.lua b/Bio_Industries_2/settings_changed.lua
index 9126db9..342948a 100644
--- a/Bio_Industries_2/settings_changed.lua
+++ b/Bio_Industries_2/settings_changed.lua
@@ -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