private void CreatePlanet(int seed, float size)
        {
            Vector3D pos = MySector.MainCamera.Position + MySector.MainCamera.ForwardVector * size * 3 - new Vector3D(size);

            MyPlanetGeneratorDefinition planetDefinition = MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(m_selectedPlanetName));
            MyPlanetStorageProvider     provider         = new MyPlanetStorageProvider();

            provider.Init(seed, planetDefinition, size / 2f);

            IMyStorage storage = new MyOctreeStorage(provider, provider.StorageSize);

            float minHillSize = provider.Radius * planetDefinition.HillParams.Min;
            float maxHillSize = provider.Radius * planetDefinition.HillParams.Max;

            float averagePlanetRadius = provider.Radius;

            float outerRadius = averagePlanetRadius + maxHillSize;
            float innerRadius = averagePlanetRadius + minHillSize;

            float atmosphereRadius = planetDefinition.AtmosphereSettings.HasValue && planetDefinition.AtmosphereSettings.Value.Scale > 1f ? 1 + planetDefinition.AtmosphereSettings.Value.Scale : 1.75f;

            atmosphereRadius *= provider.Radius;

            var planet = new MyPlanet();

            planet.EntityId = MyRandom.Instance.NextLong();

            MyPlanetInitArguments planetInitArguments;

            planetInitArguments.StorageName           = "test";
            planetInitArguments.Storage               = storage;
            planetInitArguments.PositionMinCorner     = pos;
            planetInitArguments.Radius                = provider.Radius;
            planetInitArguments.AtmosphereRadius      = atmosphereRadius;
            planetInitArguments.MaxRadius             = outerRadius;
            planetInitArguments.MinRadius             = innerRadius;
            planetInitArguments.HasAtmosphere         = planetDefinition.HasAtmosphere;
            planetInitArguments.AtmosphereWavelengths = Vector3.Zero;
            planetInitArguments.GravityFalloff        = planetDefinition.GravityFalloffPower;
            planetInitArguments.MarkAreaEmpty         = true;
            planetInitArguments.AtmosphereSettings    = planetDefinition.AtmosphereSettings.HasValue ? planetDefinition.AtmosphereSettings.Value : MyAtmosphereSettings.Defaults();
            planetInitArguments.SurfaceGravity        = planetDefinition.SurfaceGravity;
            planetInitArguments.AddGps                = false;
            planetInitArguments.SpherizeWithDistance  = true;
            planetInitArguments.Generator             = planetDefinition;
            planetInitArguments.UserCreated           = true;

            planet.Init(planetInitArguments);

            m_lastAsteroidInfo = new SpawnAsteroidInfo()
            {
                Asteroid         = null,
                RandomSeed       = seed,
                Position         = Vector3D.Zero,
                IsProcedural     = true,
                ProceduralRadius = size,
            };

            MyCubeBuilder.Static.ActivateVoxelClipboard(planet.GetObjectBuilder(), storage, MySector.MainCamera.ForwardVector, (storage.Size * 0.5f).Length());
        }
Example #2
0
        private void PlanetListItemClicked(MyGuiControlListbox box)
        {
            if (box.SelectedItems.Count > 0)
            {
                MyEntityList.MyEntityListInfoItem myEntityListInfoItem = (MyEntityList.MyEntityListInfoItem)box.SelectedItems[box.SelectedItems.Count - 1].UserData;
                m_attachedEntity = myEntityListInfoItem.EntityId;
                if (!TryAttachCamera(myEntityListInfoItem.EntityId))
                {
                    MySession.Static.SetCameraController(MyCameraControllerEnum.Spectator, null, myEntityListInfoItem.Position + Vector3.One * 50f);
                }

                MyPlanet planetEntity = (MyPlanet)MyEntities.GetEntityById(myEntityListInfoItem.EntityId);

                string name = "";
                if (myEntityListInfoItem.DisplayName.StartsWith("Planet"))
                {
                    name = myEntityListInfoItem.DisplayName.Replace("_", " ").Split('-')[0].Trim();
                }
                else
                {
                    name = myEntityListInfoItem.DisplayName.Replace("_", " ");
                }

                if (m_selectedPlanet != null)
                {
                    PluginDrawSession.Static.RemoveRenderObject(m_selectedPlanet.GetHashCode());
                }

                SystemGenerator.Static.GetObject(name, delegate(bool success, MySystemItem obj)
                {
                    if (success)
                    {
                        m_selectedPlanet = (MyPlanetItem)obj;
                        m_newPlanet      = false;
                    }
                    else
                    {
                        m_selectedPlanet = new MyPlanetItem()
                        {
                            DisplayName    = myEntityListInfoItem.DisplayName.Replace("_", " "),
                            CenterPosition = planetEntity.PositionComp.GetPosition(),
                            DefName        = ((MyObjectBuilder_Planet)planetEntity.GetObjectBuilder()).Name,
                            Generated      = true,
                            OffsetPosition = planetEntity.PositionLeftBottomCorner,
                            PlanetMoons    = new MyPlanetMoonItem[0],
                            PlanetRing     = null,
                            Size           = planetEntity.AverageRadius * 2,
                            Type           = SystemObjectType.PLANET
                        };
                        m_newPlanet = true;
                    }

                    m_ringDistanceSlider.MinValue  = planetEntity.AverageRadius * 2 * 0.75f - planetEntity.AverageRadius;
                    m_ringDistanceSlider.MinValue -= m_ringDistanceSlider.MinValue % 1000;
                    m_ringDistanceSlider.MaxValue  = planetEntity.AverageRadius * 2 * 2 - planetEntity.AverageRadius;
                    m_ringDistanceSlider.MaxValue -= m_ringDistanceSlider.MaxValue % 1000;
                    m_ringDistanceSlider.Value     = planetEntity.AverageRadius * 2 * 1.25f - planetEntity.AverageRadius;
                    m_ringDistanceSlider.Value    -= m_ringDistanceSlider.Value % 1000;

                    bool hasRing = m_selectedPlanet.PlanetRing != null;

                    m_ringAngleXSlider.Enabled      = !hasRing;
                    m_ringAngleYSlider.Enabled      = !hasRing;
                    m_ringAngleZSlider.Enabled      = !hasRing;
                    m_ringDistanceSlider.Enabled    = !hasRing;
                    m_ringWidthSlider.Enabled       = !hasRing;
                    m_ringRoidSizeSlider.Enabled    = !hasRing;
                    m_ringRoidSizeMaxSlider.Enabled = !hasRing;
                    m_addRingButton.Enabled         = !hasRing;
                    m_removeRingButton.Enabled      = hasRing;
                    m_teleportToRingButton.Enabled  = hasRing;

                    if (hasRing)
                    {
                        m_ringDistanceSlider.Value    = (float)m_selectedPlanet.PlanetRing.Radius - m_selectedPlanet.Size / 2;
                        m_ringWidthSlider.Value       = m_selectedPlanet.PlanetRing.Width;
                        m_ringAngleZSlider.Value      = m_selectedPlanet.PlanetRing.AngleDegrees;
                        m_ringAngleYSlider.Value      = m_selectedPlanet.PlanetRing.AngleDegreesY;
                        m_ringAngleXSlider.Value      = m_selectedPlanet.PlanetRing.AngleDegreesX;
                        m_ringRoidSizeSlider.Value    = m_selectedPlanet.PlanetRing.RoidSize;
                        m_ringRoidSizeMaxSlider.Value = m_selectedPlanet.PlanetRing.RoidSizeMax;
                    }
                    else
                    {
                        m_ringWidthSlider.Value       = m_ringWidthSlider.DefaultValue.Value;
                        m_ringAngleXSlider.Value      = m_ringAngleXSlider.DefaultValue.Value;
                        m_ringAngleYSlider.Value      = m_ringAngleXSlider.DefaultValue.Value;
                        m_ringAngleZSlider.Value      = m_ringAngleXSlider.DefaultValue.Value;
                        m_ringRoidSizeSlider.Value    = m_ringRoidSizeSlider.MinValue;
                        m_ringRoidSizeMaxSlider.Value = m_ringRoidSizeMaxSlider.MaxValue;
                        m_ringRoidSizeSlider.Value    = m_ringRoidSizeSlider.DefaultValue.Value;
                        m_ringRoidSizeMaxSlider.Value = m_ringRoidSizeMaxSlider.DefaultValue.Value;
                    }

                    m_ringRoidSizeValue.Text = m_ringRoidSizeSlider.Value.ToString();
                    m_ringAngleXValue.Text   = String.Format("{0:0.00}", m_ringAngleXSlider.Value);
                    m_ringAngleYValue.Text   = String.Format("{0:0.00}", m_ringAngleYSlider.Value);
                    m_ringAngleZValue.Text   = String.Format("{0:0.00}", m_ringAngleZSlider.Value);
                    m_ringWidthValue.Text    = m_ringWidthSlider.Value.ToString();
                    m_ringDistanceValue.Text = m_ringDistanceSlider.Value.ToString();

                    UpdateRingVisual();
                });
            }
        }