public override void UpdateBeforeSimulation()
        {
            base.UpdateBeforeSimulation();

            m_updateCounter++;
            if (m_updateCounter % 100 == 0 && MySession.Static.LocalCharacter != null)
            {
                m_detectedGrids.Clear();
                BoundingSphereD playerSphere = new BoundingSphereD(MySession.Static.LocalCharacter.PositionComp.GetPosition(), 500f);
                MyGamePruningStructure.GetAllTopMostEntitiesInSphere(ref playerSphere, m_detectedGrids);
                for (int i = 0; i < m_detectedGrids.Count; i++)
                {
                    MyCubeGrid grid = m_detectedGrids[i] as MyCubeGrid;
                    if (grid != null)
                    {
                        foreach (var block in grid.CubeBlocks)
                        {
                            if (block.FatBlock is MyFunctionalBlock)
                                (block.FatBlock as MyFunctionalBlock).UpdateSoundEmitters();
                        }
                    }
                }
                foreach (var key in m_emitterLibraryToRemove)
                {
                    if (m_emitterLibrary.ContainsKey(key))
                    {
                        m_emitterLibrary[key].StopSound(true);
                        m_emitterLibrary.Remove(key);
                    }
                }
                m_emitterLibraryToRemove.Clear();
                foreach (var emitter in m_emitterLibrary.Values)
                    emitter.Update();
            }
        }

 public static bool Intersects(this MyPlanet planet, BoundingSphereD sphere)
 {
     Vector3D centre = sphere.Center;
     Vector3D closestPoint = planet.GetClosestSurfacePointGlobal(ref centre);
     double minDistance = sphere.Radius; minDistance *= minDistance;
     return Vector3D.DistanceSquared(centre, closestPoint) <= minDistance;
 }

        private void FindNearbyStuff()
        {
            var bs = new BoundingSphereD(Ship.GetPosition(), ConquestMod.MaxEngagementRange);
            var ents = MyAPIGateway.Entities.GetEntitiesInSphere(ref bs);
            var closeBy = ents;
            //entitiesFiltered.Where(z => (z.GetPosition() - drone.GetPosition()).Length() < MaxEngagementRange).ToList();

            //var closeAsteroids = asteroids.Where(z => (z.GetPosition() - drone.GetPosition()).Length() < MaxEngagementRange).ToList();

            ClearNearbyObjects();
            foreach (var closeItem in closeBy)
            {
                try
                {
                    if (closeItem is Sandbox.ModAPI.IMyCubeGrid)
                        AddNearbyFloatingItem(closeItem);

                    if (closeItem is IMyVoxelBase)
                    {
                        //_entitiesNearDcDrones.Add(closeItem)
                        AddNearbyAsteroid((IMyVoxelBase) closeItem);
                    }
                }
                catch
                {
                    //This catches duplicate key entries being put in KnownEntities.
                }
            }
        }

        public static bool FindClosestTreeInRadius(Vector3D fromPosition, float radius, out ItemInfo result)
        {
            result = default(ItemInfo);

            BoundingSphereD sphere = new BoundingSphereD(fromPosition, (double)radius);
            var entities = MyEntities.GetEntitiesInSphere(ref sphere);

            double closestDistanceSq = double.MaxValue;

            foreach (MyEntity entity in entities)
            {
                MyTrees trees = entity as MyTrees;
                if (trees == null) continue;

                trees.GetPhysicalItemsInRadius(fromPosition, radius, m_tmpEnvItemList);

                foreach (var tree in m_tmpEnvItemList)
                {
                    double distanceSq = Vector3D.DistanceSquared(fromPosition, tree.Transform.Position);
                    if (distanceSq < closestDistanceSq)
                    {
                        result.ItemsEntityId = entity.EntityId;
                        result.ItemId = tree.LocalId;
                        result.Target = tree.Transform.Position;
                        closestDistanceSq = distanceSq;
                    }
                }
            }

			entities.Clear();

            return closestDistanceSq != double.MaxValue;
        }

        private void FindNearbyStuff()
        {
            var bs = new BoundingSphereD(Ship.GetPosition(), ConquestMod.MaxEngagementRange);
            var ents = MyAPIGateway.Entities.GetEntitiesInSphere(ref bs);
            var closeBy = ents;//entitiesFiltered.Where(z => (z.GetPosition() - drone.GetPosition()).Length() < MaxEngagementRange).ToList();

            //var closeAsteroids = asteroids.Where(z => (z.GetPosition() - drone.GetPosition()).Length() < MaxEngagementRange).ToList();

            ClearNearbyObjects();
            foreach (var closeItem in closeBy)
            {
                try
                {
                    if (closeItem is IMyCubeGrid && !closeItem.Transparent && closeItem.Physics.Mass > 2000)
                        AddNearbyFloatingItem(closeItem);

                    if (closeItem is IMyVoxelBase)
                    {
                        ConquestDroneManager.GetInstance().AddDiscoveredAsteroid(closeItem as IMyVoxelBase);
                        AddNearbyAsteroid((IMyVoxelBase)closeItem);
                    }
                }
                catch
                {
                    //This catches duplicate key entries being put in KnownEntities.
                }
            }
        }

        public static void UpdateLcds()
        {
            if (!EconomyScript.Instance.ServerConfig.EnableLcds)
                return;

            var players = new List<IMyPlayer>();
            MyAPIGateway.Players.GetPlayers(players, p => p != null);
            var updatelist = new HashSet<IMyTextPanel>();

            foreach (var player in players)
            {
                // Establish a visual range of the LCD.
                // if there are no players closer than this, don't bother updating it.
                var sphere = new BoundingSphereD(player.GetPosition(), 75);
                var list = MyAPIGateway.Entities.GetEntitiesInSphere(ref sphere);
                foreach (var block in list)
                {
                    // TODO: projected ship check?
                    var textPanel = block as IMyTextPanel;
                    if (textPanel != null
                        && textPanel.IsFunctional
                        && textPanel.IsWorking
                        && EconomyConsts.LCDTags.Any(tag => textPanel.CustomName.IndexOf(tag, StringComparison.InvariantCultureIgnoreCase) >= 0))
                    {
                        updatelist.Add((IMyTextPanel)block);
                    }
                }
            }

            foreach (var textPanel in updatelist)
                ProcessLcdBlock(textPanel);
        }

 public MySphereDensityFunction(Vector3D center, double radius, double additionalFalloff)
 {
     m_center = center;
     m_sphereMax = new BoundingSphereD(center, radius + additionalFalloff);
     m_innerRadius = radius;
     m_halfFalloff = additionalFalloff / 2.0;
     m_middleRadius = radius + m_halfFalloff;
     m_outerRadius = radius + additionalFalloff;
 }

        public static void CollectObjects(ulong steamId, Vector3D destination, double range)
        {
            var sphere = new BoundingSphereD(destination, range);
            var floatingList = MyAPIGateway.Entities.GetEntitiesInSphere(ref sphere);
            //floatingList = floatingList.Where(e => (e is Sandbox.ModAPI.IMyFloatingObject) || (e is Sandbox.ModAPI.IMyCharacter)).ToList();
            floatingList = floatingList.Where(e => (e is Sandbox.ModAPI.IMyFloatingObject) || (e is Sandbox.Game.Entities.MyReplicableEntity)).ToList();

            _instance._timer100.Stop();
            _instance._workQueue.Clear();
            for (var i = 0; i < floatingList.Count; i++)
            {
                var item = floatingList[i];

                // Check for null physics and IsPhantom, to prevent picking up primitives.
                if (item.Physics != null && !item.Physics.IsPhantom)
                {
                    if (item is Sandbox.ModAPI.IMyCharacter)
                    {
                        var character = item.GetObjectBuilder() as MyObjectBuilder_Character;
                        if (!character.Health.HasValue || character.Health.Value > 0) // ignore living players
                        {
                            // TODO: not working currently. It causes body duplicates?

                            //item.Physics.ClearSpeed();
                            //_workQueue.Enqueue(delegate() { item.SetPosition(destination); });
                        }
                    }
                    else if (item is IMyFloatingObject || item is Sandbox.Game.Entities.MyReplicableEntity)
                    {
                        // Need to queue the objects, and relocate them over a number of frames, otherwise if they
                        // are all moved simultaneously to the same point in space, they will become stuck.

                        _instance._workQueue.Enqueue(delegate()
                        {
                            //item.SyncObject.UpdatePosition(); // causes Null exception.

                            if (item.Physics != null)
                            {
                                if (MyAPIGateway.Multiplayer.MultiplayerActive)
                                {
                                    item.Physics.ClearSpeed();
                                    item.SetPosition(destination); // Doesn't sync to the server.
                                    ConnectionHelper.SendMessageToAllPlayers(new MessageSyncEntityPosition() {EntityId = item.EntityId, Position = destination});
                                }
                                else if (item.Physics != null)
                                {
                                    item.Physics.ClearSpeed();
                                    item.SetPosition(destination); // Doesn't sync to the server.
                                }
                            }
                        });
                    }
                }
            }
            if (_instance._workQueue.Count > 0)
                _instance._timer100.Start();
        }

        public void Init(BoundingSphereD explosion, float explosionDamage)
        {
            m_explosion = explosion;
            m_explosionDamage = explosionDamage;

            AffectedCubeBlocks.Clear();
            AffectedCubeGrids.Clear();
            m_damageRemaining.Clear();
            m_damagedBlocks.Clear();
            m_castBlocks.Clear();
        }

        // admin scan x y z radius
        public override bool HandleCommand(ulong userId, string[] words)
        {
            if (words.Count() != 8 && words.Count() != 0)
                return false;

            if (words.Count() != 8)
            {
                Communication.SendPrivateInformation(userId, GetHelp());
                return true;
            }

            // Test Input
            float test = 0;
            for(int r = 0; r < 8; r++)
            {
                if(!float.TryParse(words[r], out test))
                {
                    Communication.SendPrivateInformation(userId, string.Format("The value at position {0} - '{1}' is invalid.  Please try the command again.", r + 1, words[r]));
                    return true;
                }
            }

            Vector3D startPosition = new Vector3D(float.Parse(words[0]), float.Parse(words[1]), float.Parse(words[2]));
            Vector3D targetPosition = new Vector3D(float.Parse(words[3]), float.Parse(words[4]), float.Parse(words[5]));
            float distance = float.Parse(words[6]);
            float radius = float.Parse(words[7]);

            Vector3D targetMovement = targetPosition - startPosition;
            targetMovement.Normalize();
            Vector3D finalPosition = targetMovement * distance;
            finalPosition += startPosition;

            List<MyObjectBuilder_CubeGrid> gridsToMove = new List<MyObjectBuilder_CubeGrid>();
            BoundingSphereD sphere = new BoundingSphereD(finalPosition, radius);
            List<IMyEntity> entities = MyAPIGateway.Entities.GetEntitiesInSphere(ref sphere);
            int count = 0;

            Communication.SendPrivateInformation(userId, string.Format("Scanning {0} meters around {1}", radius, General.Vector3DToString(finalPosition)));
            Wrapper.GameAction(() =>
            {
                foreach (IMyEntity entity in entities)
                {
                    if (!(entity is IMyCubeGrid))
                        continue;

                    Communication.SendPrivateInformation(userId, string.Format("Found ship {0} at {1}", entity.DisplayName, General.Vector3DToString(entity.GetPosition())));
                    count++;
                }
            });

            Communication.SendPrivateInformation(userId, string.Format("Total ships found: {0}", count));
            return true;
        }

 public static void GetAllBroadcastersInSphere(BoundingSphereD sphere, List<MyDataBroadcaster> result)
 {
     m_aabbTree.OverlapAllBoundingSphere<MyDataBroadcaster>(ref sphere, result, false);
     for(int i = result.Count -1; i >= 0; i--)
     {
         var x = result[i];
         var dst = (sphere.Radius + ((MyRadioBroadcaster)x).BroadcastRadius);
         dst*=dst;
         if (Vector3D.DistanceSquared(sphere.Center, x.BroadcastPosition) > dst)
             result.RemoveAtFast(i);
     }
 }

        public override bool HandleCommand( ulong userId, string[] words )
        {
            Essentials.Log.Info( "Asteroid cleanup" );
            HashSet<IMyEntity> entities = new HashSet<IMyEntity>( );
            Wrapper.GameAction( ( ) =>
                                {
                                    MyAPIGateway.Entities.GetEntities( entities );
                                    foreach ( IMyEntity entity in entities )
                                    {
                                        if ( entity == null )
                                            continue;

                                        if ( entity is IMyVoxelMap )
                                            asteroidPositions.Add( entity.PositionComp.GetPosition( ), (IMyVoxelMap)entity );
                                        else
                                            entityPositions.Add( entity.PositionComp.GetPosition( ) );
                                    }
                                } );
            //TODO: Use a thread pool to speed this up?
            DateTime profile = DateTime.Now;
            Communication.SendPrivateInformation( userId, $"Found {asteroidPositions.Count} asteroids." );
            foreach ( var asteroid in asteroidPositions )
            {
                bool found = false;
                BoundingSphereD bound = new BoundingSphereD( asteroid.Key, 1000 );
                foreach ( Vector3D checkPosition in entityPositions )
                {
                    if ( bound.Contains( checkPosition ) == ContainmentType.Contains )
                    {
                        found = true;
                        break;
                    }
                }

                if ( !found )
                    toRemove.Add( asteroid.Value );
            }
            Communication.SendPrivateInformation( userId, $"Found {toRemove.Count} asteroids to remove." );
            int count = 0;
            foreach ( IMyVoxelMap asteroid in toRemove )
            {
                if ( asteroid == null || asteroid.Closed )
                    continue;

                count++;

                Wrapper.GameAction( ( ) => asteroid.Close( ) );
            }
            Communication.SendPrivateInformation( userId, $"Removed {count} asteroids." );
            Essentials.Log.Info( "Asteroid cleanup elapsed time: " + (DateTime.Now - profile) );
            return true;
        }

        //  Blends-out triangles affected by explosion (radius + some safe delta). Triangles there have zero alpha are flaged to not-draw at all.
        public static void HideTrianglesAfterExplosion(MyVoxelBase voxelMap, ref BoundingSphereD explosionSphere)
        {
            VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyDecals::HideTrianglesAfterExplosion");
            //MyMwcVector3Int renderCellCoord = voxelMap.GetVoxelRenderCellCoordinateFromMeters(ref explosionSphere.Center);
            //m_decalsForVoxels.HideTrianglesAfterExplosion(voxelMap.VoxelMapId, ref renderCellCoord, ref explosionSphere);

            foreach (uint id in voxelMap.Render.RenderObjectIDs)
            {
                VRageRender.MyRenderProxy.HideDecals(id, explosionSphere.Center, (float)explosionSphere.Radius);
            }

            VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
        }

        public bool Contains(IMyEntity entity)
        {
            switch (Shape)
            {
                case ProtectionAreaShape.Cube:
                    var boundingBox = new BoundingBoxD(new Vector3D(Center.X - Size, Center.Y - Size, Center.Z - Size), new Vector3D(Center.X + Size, Center.Y + Size, Center.Z + Size));
                    return boundingBox.Intersects(entity.WorldAABB);
                case ProtectionAreaShape.Sphere:
                    var boundingSphere = new BoundingSphereD(Center, Size);
                    return boundingSphere.Intersects(entity.WorldAABB);
            }

            return false;
        }

        // /admin movefrom x y z x y z radius
        public override bool HandleCommand(ulong userId, string[] words)
        {
            if (words.Count() != 7 && words.Count() != 0)
                return false;

            if (words.Count() != 7)
            {
                Communication.SendPrivateInformation(userId, GetHelp());
                return true;
            }

            // Test Input
            float test = 0;
            for(int r = 0; r < 7; r++)
            {
                if(!float.TryParse(words[r], out test))
                {
                    Communication.SendPrivateInformation(userId, string.Format("The value at position {0} - '{1}' is invalid.  Please try the command again.", r + 1, words[r]));
                    return true;
                }
            }

            Vector3D startPosition = new Vector3(float.Parse(words[0]), float.Parse(words[1]), float.Parse(words[2]));
            Vector3D movePosition = new Vector3(float.Parse(words[3]), float.Parse(words[4]), float.Parse(words[5]));
            Vector3D difference = startPosition - movePosition;
            float radius = float.Parse(words[6]);

            Communication.SendPrivateInformation(userId, $"Moving all grids in a radius of {radius} near {startPosition} to {movePosition}" );

            BoundingSphereD sphere = new BoundingSphereD(startPosition, radius);
            List<IMyEntity> entitiesToMove = MyAPIGateway.Entities.GetEntitiesInSphere(ref sphere);
            int moveCount = 0;
            foreach ( IMyEntity entity in entitiesToMove )
            {
                if ( !( entity is IMyCubeGrid ) )
                    continue;

                Vector3D target = entity.GetPosition( ) + difference;

                Communication.SendPrivateInformation( userId, $"Moving '{entity.DisplayName}' from {entity.GetPosition( )} to {target}" );

                //position can be set directly on the server
                Wrapper.GameAction( ( ) => entity.SetPosition( target ) );
                moveCount++;
            }

            Communication.SendPrivateInformation(userId, $"Moved {moveCount} grids" );

            return true;
        }

        protected override void ReadEntitiesInRange()
        {
            m_entitiesInRange.Clear();

            BoundingSphereD bsphere = new BoundingSphereD(Center, m_radius);
            var res = MyEntities.GetEntitiesInSphere(ref bsphere);
            for (int i = 0; i < res.Count; ++i)
            {
                var rootEntity = res[i].GetTopMostParent();
                if (!IgnoredEntities.Contains(rootEntity))
                    m_entitiesInRange[rootEntity.EntityId] = new DetectionInfo(rootEntity, FrontPoint);
            }
            res.Clear();
        }

 public MyVoxelBase GetOverlappingWithSphere(ref BoundingSphereD sphere)
 {
     MyVoxelBase ret = null;
     MyGamePruningStructure.GetAllVoxelMapsInSphere(ref sphere, m_tmpVoxelMapsList);
     foreach (var voxelMap in m_tmpVoxelMapsList)
     {
         if (voxelMap.DoOverlapSphereTest((float)sphere.Radius, sphere.Center))
         {
             ret = voxelMap;
             break;
         }
     }
     m_tmpVoxelMapsList.Clear();
     return ret;
 }

 public static void ApplyEMP(BoundingSphereD location, float strength, TimeSpan duration)
 {
     MyAPIGateway.Utilities.TryInvokeOnGameThread(() => {
         MyGamePruningStructure.GetAllTopMostEntitiesInSphere(ref location, s_entitiesEMP);
         foreach (IMyEntity entity in s_entitiesEMP)
         {
             IMyCubeGrid grid = entity as IMyCubeGrid;
             if (grid != null)
             {
                 EMP e = new EMP();
                 e.Start(grid, duration, ref strength, long.MinValue);
             }
         }
         s_entitiesEMP.Clear();
     });
 }

        //  Return true if object intersects specified sphere.
        //  This method doesn't return exact point of intersection or any additional data.
        //  We don't look for closest intersection - so we stop on first intersection found.
        public override bool GetIntersectionWithSphere(ref BoundingSphereD sphere)
        {
            return false;

            //Matrix invWorld = Matrix.Invert(WorldMatrix);
            //Vector3 spherePos = Vector3.Transform(sphere.Center, invWorld);

            //var definition = MyDefinitionManager.Static.GetCubeBlockDefinition(new MyDefinitionId(MyObjectBuilderTypeEnum.Ladder));
            //if (definition.ExcludedAreaForCamera != null)
            //    foreach (var b in definition.ExcludedAreaForCamera)
            //    {
            //        if (b.Contains(new BoundingSphere(spherePos, sphere.Radius)) != ContainmentType.Disjoint)
            //            return false;
            //    }

            //return base.GetIntersectionWithSphere(ref sphere);
        }

        // admin scan x y z radius
        public override bool HandleCommand(ulong userId, string[] words)
        {
            if (words.Count() != 4 && words.Count() != 0)
                return false;

            if (!words.Any())
            {
                Communication.SendPrivateInformation(userId, GetHelp());
                return true;
            }

            // Test Input
            float test = 0;
            for(int r = 0; r < 4; r++)
            {
                if(!float.TryParse(words[r], out test))
                {
                    Communication.SendPrivateInformation(userId, string.Format("The value at position {0} - '{1}' is invalid.  Please try the command again.", r + 1, words[r]));
                    return true;
                }
            }

            Vector3D startPosition = new Vector3(float.Parse(words[0]), float.Parse(words[1]), float.Parse(words[2]));
            float radius = float.Parse(words[3]);

            List<MyObjectBuilder_CubeGrid> gridsToMove = new List<MyObjectBuilder_CubeGrid>();
            BoundingSphereD sphere = new BoundingSphereD(startPosition, radius);
            List<IMyEntity> entitiesToMove = MyAPIGateway.Entities.GetEntitiesInSphere(ref sphere);
            int count = 0;

            Wrapper.GameAction(() =>
            {
                foreach (IMyEntity entity in entitiesToMove)
                {
                    if (!(entity is IMyCubeGrid))
                        continue;

                    Communication.SendPrivateInformation(userId, string.Format("Found ship '{0}' ({1}) at {2}", entity.DisplayName, entity.EntityId, General.Vector3DToString(entity.GetPosition())));
                    count++;
                }
            });

            Communication.SendPrivateInformation(userId, string.Format("Total ships found: {0}", count));
            return true;
        }