/// <summary>
        /// Tries to find a ring in the system, that contains the given position.
        /// </summary>
        /// <param name="position">Position</param>
        /// <returns>The first ring found, that contains the given position.</returns>
        private MySystemAsteroids GetAsteroidObjectAt(Vector3D position)
        {
            var systemObjects = MyStarSystemGenerator.Static.StarSystem.GetAllObjects();

            foreach (var obj in systemObjects)
            {
                if (obj.Type != MySystemObjectType.ASTEROIDS)
                {
                    continue;
                }
                var asteroids = obj as MySystemAsteroids;

                var prov = MyAsteroidObjectsManager.Static.AsteroidObjectProviders[asteroids.AsteroidTypeName];

                IMyAsteroidObjectShape shape = prov.GetAsteroidObjectShape(asteroids);

                if (shape == null)
                {
                    return(null);
                }

                if (shape.Contains(position) == ContainmentType.Contains)
                {
                    return(obj as MySystemAsteroids);
                }
            }

            return(null);
        }
        /// <summary>
        /// Checks, whether a given position, where a moon with given diameter is located, is obstructed by moons or a planet or its ring.
        /// Helper method for GeneratePlanetMoons
        /// </summary>
        /// <param name="position">Position to check</param>
        /// <param name="moonDiameter">Diameter of moon</param>
        /// <param name="parentPlanet">Planet to check ring</param>
        /// <param name="moons">Moons to check</param>
        /// <returns></returns>
        private bool IsMoonPositionObstructed(Vector3D position, double moonDiameter, MySystemPlanet parentPlanet, MySystemPlanetMoon[] moons)
        {
            if (Vector3D.Distance(position, parentPlanet.CenterPosition) < moonDiameter + parentPlanet.Diameter)
            {
                return(true);
            }

            foreach (var child in parentPlanet.ChildObjects)
            {
                if (child.Type == MySystemObjectType.ASTEROIDS)
                {
                    var asteroid = child as MySystemAsteroids;
                    IMyAsteroidObjectShape shape = MyAsteroidObjectsManager.Static.AsteroidObjectProviders[asteroid.AsteroidTypeName].GetAsteroidObjectShape(asteroid);
                    if (Vector3D.Distance(shape.GetClosestPoint(position), position) <= moonDiameter)
                    {
                        return(true);
                    }
                }
                else
                {
                    if (child.GetType() == typeof(MySystemPlanet))
                    {
                        if (Vector3D.Distance(child.CenterPosition, position) < moonDiameter + (child as MySystemPlanet).Diameter)
                        {
                            return(true);
                        }
                    }
                }
            }

            foreach (var moon in moons)
            {
                if (moon == null)
                {
                    continue;
                }
                if (Vector3D.Distance(moon.CenterPosition, position) < moonDiameter + moon.Diameter)
                {
                    return(true);
                }
            }

            return(false);
        }
        /// <summary>
        /// Teleports the player to the selected ring
        /// </summary>
        /// <param name="button">Button to call</param>
        private void OnTeleportToSphere(MyGuiControlButton button)
        {
            MyPluginLog.Debug("Teleporting player to " + m_currentSelectedAsteroid.DisplayName);

            if (MySession.Static.CameraController != MySession.Static.LocalCharacter || true)
            {
                if (m_currentSelectedAsteroid != null)
                {
                    IMyAsteroidObjectShape shape = MyAsteroidSphereProvider.Static.GetAsteroidObjectShape(m_currentSelectedAsteroid);
                    if (shape == null)
                    {
                        MyPluginGuiHelper.DisplayError("Cant teleport to asteroid sphere. It does not exist", "Error");
                        return;
                    }

                    m_parentScreen.CloseScreenNow();

                    MyMultiplayer.TeleportControlledEntity(shape.GetPointInShape());
                    MyGuiScreenGamePlay.SetCameraController();
                }
            }
        }
        public override void UpdateGpsForPlayer(MyEntityTracker entity)
        {
            if (!(entity.Entity is MyCharacter))
            {
                return;
            }

            var settings = MySettingsSession.Static.Settings.GeneratorSettings.GPSSettings;

            if (settings.AsteroidGPSMode != MyGPSGenerationMode.DISCOVERY)
            {
                return;
            }

            var         objects = MyStarSystemGenerator.Static.StarSystem.GetAllObjects();
            MyCharacter player  = entity.Entity as MyCharacter;

            foreach (var obj in objects)
            {
                if (obj.Type != MySystemObjectType.ASTEROIDS)
                {
                    continue;
                }

                MySystemAsteroids asteroid       = obj as MySystemAsteroids;
                Vector3D          entityPosition = player.PositionComp.GetPosition();
                var provider = MyAsteroidObjectsManager.Static.AsteroidObjectProviders[asteroid.AsteroidTypeName];

                IMyAsteroidObjectShape shape = provider.GetAsteroidObjectShape(asteroid);

                if (shape == null)
                {
                    continue;
                }

                if (shape.Contains(entityPosition) != ContainmentType.Disjoint)
                {
                    MyGPSManager.Static.RemoveDynamicGps(player.GetPlayerIdentityId(), asteroid.Id);
                }

                Vector3D closestPos = shape.GetClosestPoint(entityPosition);
                double   distance   = Vector3D.Subtract(entityPosition, closestPos).Length();
                if (distance > 5000000)
                {
                    MyGPSManager.Static.RemoveDynamicGps(player.GetPlayerIdentityId(), asteroid.Id);
                }
                else if (distance > 5)
                {
                    if (MyGPSManager.Static.DynamicGpsExists(asteroid.Id, player.GetPlayerIdentityId()))
                    {
                        MyGPSManager.Static.ModifyDynamicGps(asteroid.DisplayName, Color.Yellow, closestPos, player.GetPlayerIdentityId(), asteroid.Id);
                        continue;
                    }
                    MyGPSManager.Static.AddDynamicGps(asteroid.DisplayName, Color.Yellow, closestPos, player.GetPlayerIdentityId(), asteroid.Id);
                }
                else
                {
                    MyGPSManager.Static.RemoveDynamicGps(player.GetPlayerIdentityId(), asteroid.Id);
                }
            }
        }