diff --git a/Utility Mods/Stable/SCDefenseBlocks/Data/BlockVariantGroups_FieldGen.sbc b/Utility Mods/Stable/SCDefenseBlocks/Data/BlockVariantGroups_FieldGen.sbc
index 3f121acfa..5887ed448 100644
--- a/Utility Mods/Stable/SCDefenseBlocks/Data/BlockVariantGroups_FieldGen.sbc	
+++ b/Utility Mods/Stable/SCDefenseBlocks/Data/BlockVariantGroups_FieldGen.sbc	
@@ -5,7 +5,7 @@
       <!-- PD Turret Variants-->
       <BlockVariantGroup>
         <Id Type="MyObjectBuilder_BlockVariantGroup" Subtype="FieldGen_Variants" />
-        <Icon>Textures\GUI\Icons\MyGat.dds</Icon>
+        <Icon>Textures\GUI\Icons\Cubes\Core_Icon.dds</Icon>
         <DisplayName>[SI] Field Generator</DisplayName>
         <Description></Description>
         <Blocks>
diff --git a/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/API/APIBase.cs b/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/API/APIBase.cs
new file mode 100644
index 000000000..f16891d7f
--- /dev/null
+++ b/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/API/APIBase.cs	
@@ -0,0 +1,232 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Sandbox.ModAPI;
+using VRage.Game.Entity;
+
+namespace FieldGenerator.API
+{
+    public class FieldGeneratorAPI
+    {
+        private bool _initialized;
+
+        private Func<long, IMyFunctionalBlock> _getFirstFieldGeneratorOnGrid;
+
+        private Func<IMyFunctionalBlock, bool> _isSiegeActive;
+        private Action<IMyFunctionalBlock, bool> _setSiegeActive;
+
+        private Func<IMyFunctionalBlock, bool> _isSiegeCooldownActive;
+        private Action<IMyFunctionalBlock, bool> _setSiegeCooldownActive;
+
+        private Func<IMyFunctionalBlock, int> _getSiegeCooldown;
+        private Action<IMyFunctionalBlock, int> _setSiegeCooldown;
+
+        private Func<IMyFunctionalBlock, float> _getFieldPower;
+        private Action<IMyFunctionalBlock, float> _setFieldPower;
+
+        private Func<IMyFunctionalBlock, float> _getMaximumFieldPower;
+        private Func<IMyFunctionalBlock, float>_getMinimumFieldPower;
+
+        private Func<IMyFunctionalBlock, float> _getPowerDraw;
+
+        private Func<IMyFunctionalBlock, float> _getStability;
+        private Action<IMyFunctionalBlock, float> _setStability;
+
+        /// <summary>
+        /// Returns first valid field generator for the specified grid EntityID.
+        /// </summary>
+        /// <param name="entityID">EntityID of the cubegrid to check against.</param>
+        /// <returns><c>IMyFunctionalBlock</c> of the first field generator if one exists; otherwise, <c>null</c>.</returns>
+        public IMyFunctionalBlock GetFirstFieldGeneratorOnGrid(long entityID) => _getFirstFieldGeneratorOnGrid?.Invoke(entityID) ?? null;
+
+        /// <summary>
+        /// Returns whether or not the specified block is in siege mode.
+        /// </summary>
+        /// <param name="block">Block  to check.</param>
+        /// <returns><c>true</c> if siege mode is active; otherwise, <c>false</c>.</returns>
+        public bool IsSiegeActive(IMyFunctionalBlock block) => _isSiegeActive?.Invoke(block) ?? false;
+
+        /// <summary>
+        /// Sets the siege mode state on the given block.
+        /// </summary>
+        /// <param name="block">Block whose siege state will be modified.</param>
+        /// <param name="Active">Whether siege mode should be active (<c>true</c>) or inactive (<c>false</c>).</param>
+        public void SetSiegeActive(IMyFunctionalBlock block, bool Active) => _setSiegeActive?.Invoke(block, Active);
+
+        /// <summary>
+        /// Returns whether or not the specified blocks siege mode is on cooldown.
+        /// </summary>
+        /// <param name="block">Block to check.</param>
+        /// <returns><c>true</c> if the cooldown is active; otherwise, <c>false</c>.</returns>
+        public bool IsSiegeCooldownActive(IMyFunctionalBlock block) => _isSiegeCooldownActive?.Invoke(block) ?? false;
+
+        /// <summary>
+        /// Sets the siege mode cooldown state on the given block.
+        /// </summary>
+        /// <param name="block">Block whose cooldown state will be modified.</param>
+        /// <param name="Active">Whether the cooldown should be active (<c>true</c>) or inactive (<c>false</c>).</param>
+        public void SetSiegeCooldownActive(IMyFunctionalBlock block, bool Active) => _setSiegeCooldownActive?.Invoke(block, Active);
+
+        /// <summary>
+        /// Returns the specified blocks current cooldown time.
+        /// </summary>
+        /// <param name="block">Block to check.</param>
+        /// <returns>The siege cooldown time, or <c>0</c> if no cooldown is active.</returns>
+        public int GetSiegeCooldown(IMyFunctionalBlock block) => _getSiegeCooldown?.Invoke(block) ?? 0;
+
+        /// <summary>
+        /// Sets the cooldown time on the given block.
+        /// </summary>
+        /// <param name="block">Block whose cooldown will be modified.</param>
+        /// <param name="Time">Time to set the cooldown to, in seconds.</param>
+        public void SetSiegeCooldown(IMyFunctionalBlock block, int Time) => _setSiegeCooldown?.Invoke(block, Time);
+
+        /// <summary>
+        /// Returns the specified block current field power.
+        /// </summary>
+        /// <param name="block">Block to check.</param>
+        /// <returns>The current field power.</returns>
+        public float GetFieldPower(IMyFunctionalBlock block) => _getFieldPower?.Invoke(block) ?? 0;
+
+        /// <summary>
+        /// Sets the field power on the given block.
+        /// </summary>
+        /// <param name="block">Block whose field power will be modified.</param>
+        /// <param name="Power">
+        /// The field power to set as a float, expressed as a percentage and capped by minimum/maximum field power.
+        /// </param>
+        public void SetFieldPower(IMyFunctionalBlock block, float Power) => _setFieldPower?.Invoke(block, Power);
+
+        /// <summary>
+        /// Returns the specified blocks maximum field power.
+        /// </summary>
+        /// <param name="block">Block to check.</param>
+        /// <returns>The maximum field power.</returns>
+        public float GetMaximumFieldPower(IMyFunctionalBlock block) => _getMaximumFieldPower?.Invoke(block) ?? 0;
+
+        /// <summary>
+        /// Returns the specified block minimum field power.
+        /// </summary>
+        /// <param name="block">Block to check.</param>
+        /// <returns>The minimum field power.</returns>
+        public float GetMinimumFieldPower(IMyFunctionalBlock block) => _getMinimumFieldPower?.Invoke(block) ?? 0;
+
+        /// <summary>
+        /// Returns the specified blocks current power draw.
+        /// </summary>
+        /// <param name="block">Block to check.</param>
+        /// <returns>The current power draw.</returns>
+        public float GetPowerDraw(IMyFunctionalBlock block) => _getPowerDraw?.Invoke(block) ?? 0;
+
+        /// <summary>
+        /// Returns the specified blocks current stability.
+        /// </summary>
+        /// <param name="block">Block to check.</param>
+        /// <returns>The current stability.</returns>
+        public float GetStability(IMyFunctionalBlock block) => _getStability?.Invoke(block) ?? 0;
+
+        /// <summary>
+        /// Sets the stability on the given block.
+        /// </summary>
+        /// <param name="block">Block whose stability will be modified.</param>
+        /// <param name="Stability">
+        /// The stability to set as a float, expressed as a percentage with a maximum of 100.
+        /// </param>
+        public void SetStability(IMyFunctionalBlock block, float Stability) => _setStability?.Invoke(block, Stability);
+
+
+        private const long HandlerID = 917632;
+        private bool _APIRegistered;
+        private Action _ReadyCallback;
+
+        public bool IsReady {  get; private set; }
+
+
+        public void LoadAPI(Action ReadyCallback = null)
+        {
+            if (_APIRegistered)
+                throw new Exception($"{GetType().Name}.LoadAPI() should not be called multiple times!");
+
+            _ReadyCallback = ReadyCallback;
+            _APIRegistered = true;
+            MyAPIGateway.Utilities.RegisterMessageHandler(HandlerID, HandleMessage);
+            MyAPIGateway.Utilities.SendModMessage(HandlerID, "APIRequest");
+        }
+
+        public void UnloadAPI()
+        {
+            MyAPIGateway.Utilities.UnregisterMessageHandler(HandlerID, HandleMessage);
+
+            ApiAssign(null);
+
+            _APIRegistered = false;
+            _initialized = false;
+            IsReady = false;
+        }
+
+        private void HandleMessage(object obj)
+        {
+            if (_initialized || obj is string) 
+                return;
+
+            var dict = obj as IReadOnlyDictionary<string, Delegate>;
+
+            if (dict == null)
+                return;
+
+            ApiAssign(dict);
+
+            IsReady = true;
+            _ReadyCallback?.Invoke();
+        }
+
+        public void ApiAssign(IReadOnlyDictionary<string, Delegate> delegates)
+        {
+            _initialized = delegates != null;
+
+            AssignMethod(delegates, "GetFirstFieldGeneratorOnGrid", ref _getFirstFieldGeneratorOnGrid);
+
+            AssignMethod(delegates, "IsSiegeActive", ref _isSiegeActive);
+            AssignMethod(delegates, "SetSiegeActive", ref _setSiegeActive);
+
+            AssignMethod(delegates, "IsSiegeCooldownActive", ref _isSiegeCooldownActive);
+            AssignMethod(delegates, "SetSiegeCooldownActive", ref _setSiegeCooldownActive);
+
+            AssignMethod(delegates, "GetSiegeCooldown", ref _getSiegeCooldown);
+            AssignMethod(delegates, "SetSiegeCooldown", ref _setSiegeCooldown);
+
+            AssignMethod(delegates, "GetFieldPower", ref _getFieldPower);
+            AssignMethod(delegates, "SetFieldPower", ref _setFieldPower);
+
+            AssignMethod(delegates, "GetMaximumFieldPower", ref _getMaximumFieldPower);
+            AssignMethod(delegates, "GetMinimumFieldPower", ref _getMinimumFieldPower);
+
+            AssignMethod(delegates, "GetPowerDraw", ref _getPowerDraw);
+
+            AssignMethod(delegates, "GetStability", ref _getStability);
+            AssignMethod(delegates, "SetStability", ref _setStability);
+        }
+
+        private void AssignMethod<T>(IReadOnlyDictionary<string, Delegate> delegates, string name, ref T field)
+            where T : class
+        {
+            if (delegates == null)
+            {
+                field = null;
+                return;
+            }
+
+            Delegate del;
+            if (!delegates.TryGetValue(name, out del))
+                throw new Exception($"{GetType().Name} :: Couldn't find {name} delegate of type {typeof(T)}");
+
+            field = del as T;
+
+            if (field == null)
+                throw new Exception(
+                    $"{GetType().Name} :: Delegate {name} is not type {typeof(T)}, instead it's: {del.GetType()}");
+        }
+    }
+}
diff --git a/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/API/APIServer.cs b/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/API/APIServer.cs
new file mode 100644
index 000000000..106649c4a
--- /dev/null
+++ b/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/API/APIServer.cs	
@@ -0,0 +1,242 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Sandbox.ModAPI;
+using VRage.Game.Entity;
+using VRage.ModAPI;
+using FieldGeneratorCore = Starcore.FieldGenerator.FieldGenerator;
+
+namespace Starcore.FieldGenerator.API
+{
+    public class APIProvider
+    {
+        private const long HandlerID = 917632;
+        private bool _registered;
+
+        public bool IsReady { get; private set; }
+
+        public void LoadAPI()
+        {
+            if (!_registered)
+            {
+                _registered = true;
+                MyAPIGateway.Utilities.RegisterMessageHandler(HandlerID, HandleMessage);
+            }
+            
+            IsReady = true;
+
+            try
+            {
+                MyAPIGateway.Utilities.SendModMessage(HandlerID, FieldGeneratorSession.I.APIBackend.APIMethods);
+            }
+            catch (Exception ex)
+            {
+                Log.Error($"Field Generator API Load Failed!" + "\n" + ex);
+            }
+        }
+
+        public void UnloadAPI()
+        {
+            if (_registered)
+            {
+                _registered = false;
+                MyAPIGateway.Utilities.UnregisterMessageHandler(HandlerID, HandleMessage);
+            }
+            IsReady = false;
+        }
+
+        private void HandleMessage(object o)
+        {
+            if ((o as string) == "APIRequest")
+                MyAPIGateway.Utilities.SendModMessage(HandlerID, FieldGeneratorSession.I.APIBackend.APIMethods);
+        }
+    }
+
+    internal class APIBackend
+    {
+        internal readonly Dictionary<string, Delegate> APIMethods;
+
+        internal APIBackend()
+        {
+            APIMethods = new Dictionary<string, Delegate>()
+            {
+                ["GetFirstFieldGeneratorOnGrid"] = new Func<long, IMyFunctionalBlock>(GetFirstFieldGeneratorOnGrid),
+
+                ["IsSiegeActive"] = new Func<IMyFunctionalBlock, bool>(IsSiegeActive),
+                ["SetSiegeActive"] = new Action<IMyFunctionalBlock, bool>(SetSiegeActive),
+
+                ["IsSiegeCooldownActive"] = new Func<IMyFunctionalBlock, bool>(IsSiegeCooldownActive),
+                ["SetSiegeCooldownActive"] = new Action<IMyFunctionalBlock, bool>(SetSiegeCooldownActive),
+
+                ["GetSiegeCooldown"] = new Func<IMyFunctionalBlock, int>(GetSiegeCooldown),
+                ["SetSiegeCooldown"] = new Action<IMyFunctionalBlock, int>(SetSiegeCooldown),
+
+                ["GetFieldPower"] = new Func<IMyFunctionalBlock, float>(GetFieldPower),
+                ["SetFieldPower"] = new Action<IMyFunctionalBlock, float>(SetFieldPower),
+
+                ["GetMaximumFieldPower"] = new Func<IMyFunctionalBlock, float>(GetMaximumFieldPower),
+                ["GetMinimumFieldPower"] = new Func<IMyFunctionalBlock, float>(GetMinimumFieldPower),
+
+                ["GetPowerDraw"] = new Func<IMyFunctionalBlock, float>(GetPowerDraw),
+
+                ["GetStability"] = new Func<IMyFunctionalBlock, float>(GetStability),
+                ["SetStability"] = new Action<IMyFunctionalBlock, float>(SetStability),
+            };
+        }
+
+        private IMyFunctionalBlock GetFirstFieldGeneratorOnGrid(long entityID)
+        {
+            if (entityID == 0)
+                return null;
+
+            HashSet<long> generators;
+            if (!FieldGeneratorSession.ActiveGenerators.TryGetValue(entityID, out generators))
+            {
+                return null;
+            }
+
+            var fieldGeneratorID = generators.FirstOrDefault();
+            if (fieldGeneratorID == 0)
+            {
+                return null;
+            }
+
+            IMyEntity generatorEntity;
+            if (!MyAPIGateway.Entities.TryGetEntityById(fieldGeneratorID, out generatorEntity))
+            {
+                return null;
+            } 
+
+            return generatorEntity as IMyFunctionalBlock;
+        }
+
+        private bool IsSiegeActive(IMyFunctionalBlock block)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                return logic.SiegeMode.Value;
+            }
+
+            return false;
+        }
+        private void SetSiegeActive(IMyFunctionalBlock block, bool Active)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                logic.SiegeMode.Value = Active;
+            }
+        }
+
+        private bool IsSiegeCooldownActive(IMyFunctionalBlock block)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                return logic.SiegeCooldownActive.Value;
+            }
+
+            return false;
+        }
+        private void SetSiegeCooldownActive(IMyFunctionalBlock block, bool Active)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                logic.SiegeCooldownActive.Value = Active;
+            }
+        }
+
+        private int GetSiegeCooldown(IMyFunctionalBlock block)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                return logic.SiegeCooldownTime.Value;
+            }
+
+            return 0;
+        }
+        private void SetSiegeCooldown(IMyFunctionalBlock block, int Time)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                logic.SiegeCooldownTime.Value = Time;
+            }
+        }
+
+        private float GetFieldPower (IMyFunctionalBlock block)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                return logic.FieldPower.Value;
+            }
+
+            return 0;
+        }
+        private void SetFieldPower(IMyFunctionalBlock block, float Power)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                logic.FieldPower.Value = Power;
+            }
+        }
+
+        private float GetMaximumFieldPower(IMyFunctionalBlock block)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                return logic.MaxFieldPower.Value;
+            }
+
+            return 0;
+        }
+        private float GetMinimumFieldPower(IMyFunctionalBlock block)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                return logic.MinFieldPower.Value;
+            }
+
+            return 0;
+        }
+
+        private float GetPowerDraw(IMyFunctionalBlock block)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                return logic.CalculatePowerDraw();
+            }
+
+            return 0;
+        }
+
+        private float GetStability(IMyFunctionalBlock block)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                return logic.Stability.Value;
+            }
+
+            return 0;
+        }
+        private void SetStability(IMyFunctionalBlock block, float Stability)
+        {
+            var logic = FieldGeneratorCore.GetLogic<FieldGeneratorCore>(block.EntityId);
+            if (logic != null)
+            {
+                logic.Stability.Value = Stability;
+            }
+        }
+    }
+}
diff --git a/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/FieldGenerator_Core.cs b/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/FieldGenerator_Core.cs
index 66b2e4743..5275154c1 100644
--- a/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/FieldGenerator_Core.cs	
+++ b/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/FieldGenerator_Core.cs	
@@ -614,7 +614,7 @@ private float CalculateSizeModifier()
             return Config.SizeModifierMin + t * (Config.SizeModifierMax - Config.SizeModifierMin);
         }
 
-        private float CalculatePowerDraw()
+        public float CalculatePowerDraw()
         {
             if (SiegeMode.Value)
             {
diff --git a/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/FieldGenerator_Session.cs b/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/FieldGenerator_Session.cs
index 0da744ce0..f78d81277 100644
--- a/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/FieldGenerator_Session.cs	
+++ b/Utility Mods/Stable/SCDefenseBlocks/Data/Scripts/OneFuckingFolderDeeper/FieldGenerator/FieldGenerator_Session.cs	
@@ -3,20 +3,45 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+
+using Sandbox.Game.Entities;
+using Sandbox.ModAPI;
 using VRage.Game.Components;
+using VRage.Game.ModAPI;
+using VRage.ModAPI;
+
+using Starcore.FieldGenerator.API;
 using CoreSystems.Api;
 using Draygo.API;
+using Sandbox.Game.Entities.Cube;
 
 namespace Starcore.FieldGenerator
 {
     [MySessionComponentDescriptor(MyUpdateOrder.AfterSimulation)]
     public class FieldGeneratorSession : MySessionComponentBase
     {
+        public static FieldGeneratorSession I;
+        public static APIProvider APIProvider;
         public static WcApi CoreSysAPI;
         public static HudAPIv2 HudAPI;
 
+        internal APIBackend APIBackend;
+        internal static readonly Dictionary<long, HashSet<long>> ActiveGenerators = new Dictionary<long, HashSet<long>>();
+
         public override void LoadData()
         {
+            I = this;
+
+            InitExistingGeneratorCounts();
+
+            MyCubeGrid.OnBlockAddedGlobally += OnBlockAddedGlobally;
+            MyCubeGrid.OnBlockRemovedGlobally += OnBlockRemovedGlobally;
+            MyAPIGateway.Entities.OnEntityAdd += OnEntityAdd;
+
+            APIBackend = new APIBackend();
+            APIProvider = new APIProvider();
+            APIProvider.LoadAPI();
+
             HudAPI = new HudAPIv2();
 
             CoreSysAPI = new WcApi();
@@ -24,7 +49,7 @@ public override void LoadData()
         }
 
         protected override void UnloadData()
-        {
+        {          
             if (HudAPI.Heartbeat)
             { 
                 HudAPI.Unload();
@@ -36,6 +61,118 @@ protected override void UnloadData()
                 CoreSysAPI.Unload();
                 CoreSysAPI = null;
             }
+
+            APIProvider.UnloadAPI();
+            APIProvider = null;
+            APIBackend = null;
+
+            MyCubeGrid.OnBlockAddedGlobally -= OnBlockAddedGlobally;
+            MyCubeGrid.OnBlockRemovedGlobally -= OnBlockRemovedGlobally;
+            MyAPIGateway.Entities.OnEntityAdd -= OnEntityAdd;
+
+            I = null;
+        }
+
+        private void OnBlockAddedGlobally<T>(T slimBlock) where T : IMySlimBlock
+        {
+            if (slimBlock?.FatBlock == null) 
+                return;
+            if (!string.Equals(slimBlock.FatBlock.BlockDefinition.SubtypeName, "FieldGen_Core",
+                              StringComparison.OrdinalIgnoreCase))
+                return;
+
+            var gridId = slimBlock.CubeGrid?.EntityId ?? 0;
+            if (gridId == 0) 
+                return;
+
+            HashSet<long> set;
+            if (!ActiveGenerators.TryGetValue(gridId, out set))
+            {
+                set = new HashSet<long>();
+                ActiveGenerators[gridId] = set;
+            }
+
+            set.Add(slimBlock.FatBlock.EntityId);
+        }
+
+        private void OnBlockRemovedGlobally<T>(T slimBlock) where T : IMySlimBlock
+        {
+            if (slimBlock?.FatBlock == null) 
+                return;
+            if (!string.Equals(slimBlock.FatBlock.BlockDefinition.SubtypeName, "FieldGen_Core", StringComparison.OrdinalIgnoreCase))
+                return;
+
+            var gridId = slimBlock.CubeGrid?.EntityId ?? 0;
+            if (gridId == 0) return;
+
+            HashSet<long> set;
+            if (ActiveGenerators.TryGetValue(gridId, out set))
+            {
+                set.Remove(slimBlock.FatBlock.EntityId);
+                if (set.Count == 0)
+                    ActiveGenerators.Remove(gridId);
+            }
+        }
+
+        private void OnEntityAdd(IMyEntity ent)
+        {
+            var grid = ent as IMyCubeGrid;
+            if (grid == null)
+                return;
+
+            var slimBlocks = new List<IMySlimBlock>();
+            grid.GetBlocks(slimBlocks);
+
+            foreach (var slimBlock in slimBlocks)
+            {
+                if (slimBlock?.FatBlock == null)
+                    continue;
+
+                if (string.Equals(slimBlock.FatBlock.BlockDefinition.SubtypeName, "FieldGen_Core", StringComparison.OrdinalIgnoreCase))
+                {
+                    var gridId = grid.EntityId;
+                    HashSet<long> set;
+                    if (!ActiveGenerators.TryGetValue(gridId, out set))
+                    {
+                        set = new HashSet<long>();
+                        ActiveGenerators[gridId] = set;
+                    }
+                    set.Add(slimBlock.FatBlock.EntityId);
+                }
+            }
+        }
+
+        private void InitExistingGeneratorCounts()
+        {
+            var allEntities = new HashSet<IMyEntity>();
+            MyAPIGateway.Entities.GetEntities(allEntities);
+            foreach (var entity in allEntities)
+            {
+                var grid = entity as IMyCubeGrid;
+                if (grid == null)
+                    continue;
+
+                var slimBlocks = new List<IMySlimBlock>();
+                grid.GetBlocks(slimBlocks);
+
+                foreach (var slimBlock in slimBlocks)
+                {
+                    if (slimBlock?.FatBlock == null)
+                        continue;
+
+                    if (string.Equals(slimBlock.FatBlock.BlockDefinition.SubtypeName, "FieldGen_Core", StringComparison.OrdinalIgnoreCase))
+                    {
+                        var gridId = grid.EntityId;
+                        HashSet<long> set;
+                        if (!ActiveGenerators.TryGetValue(gridId, out set))
+                        {
+                            set = new HashSet<long>();
+                            ActiveGenerators[gridId] = set;
+                        }
+                        set.Add(slimBlock.FatBlock.EntityId);
+                    }
+                }
+            }
         }
     }
 }