Example #1
0
        /// <summary>
        /// Creates an test system with planets of varying longitude of periapsis.
        /// Adds to game.StarSystem.
        /// </summary>
        public StarSystem CreateLongitudeTest(Game game)
        {
            StarSystem system = new StarSystem(game, "Longitude test", -1);

            Entity sun = _starFactory.CreateStar(system, GameConstants.Units.SolarMassInKG, GameConstants.Units.SolarRadiusInAu, 4.6E9, "G", 5778, 1, SpectralType.G, "_lop");

            MassVolumeDB sunMVDB = sun.GetDataBlob <MassVolumeDB>();

            double planetSemiMajAxis  = 0.387098;
            double planetEccentricity = 0.9;// 0.205630;
            double planetInclination  = 0;
            double planetLoAN         = 48.33167;
            double planetLoP          = 77.45645;
            double planetMeanLongd    = 252.25084;


            for (int i = 0; i < 13; i++)
            {
                NameDB           planetNameDB = new NameDB("planet" + i);
                SystemBodyInfoDB planetBodyDB = new SystemBodyInfoDB {
                    BodyType = BodyType.Terrestrial, SupportsPopulations = true
                };
                MassVolumeDB planetMVDB       = MassVolumeDB.NewFromMassAndRadius_AU(3.3022E23, Distance.KmToAU(2439.7));
                PositionDB   planetPositionDB = new PositionDB(system.Guid);
                planetLoP = i * 15;
                OrbitDB planetOrbitDB = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, planetMVDB.MassDry, planetSemiMajAxis, planetEccentricity, planetInclination, planetLoAN, planetLoP, planetMeanLongd, GalaxyGen.Settings.J2000);
                planetPositionDB.AbsolutePosition_AU = OrbitProcessor.GetPosition_AU(planetOrbitDB, StaticRefLib.CurrentDateTime);
                Entity planet = new Entity(system, new List <BaseDataBlob> {
                    planetPositionDB, planetBodyDB, planetMVDB, planetNameDB, planetOrbitDB
                });
            }
            game.GameMasterFaction.GetDataBlob <FactionInfoDB>().KnownSystems.Add(system.Guid);
            return(system);
        }
Example #2
0
        /// <summary>
        /// Refreshes the properties of this ViewModel.
        ///
        /// If partialRefresh is set to true, the ViewModel will try to update only data changes during a pulse.
        /// </summary>
        public void Refresh(bool partialRefresh = false)
        {
            // Get up-to-date datablobs for this entity.
            PositionDB positionDB = _entity.GetDataBlob <PositionDB>();

            UpdateProperties(positionDB);

            SystemBodyInfoDB systemBodyDB = _entity.GetDataBlob <SystemBodyInfoDB>();

            UpdateProperties(systemBodyDB, partialRefresh);

            NameDB nameDB = _entity.GetDataBlob <NameDB>();

            UpdateProperties(nameDB);

            //AtmosphereDB atmosphereDB = _entity.GetDataBlob<AtmosphereDB>();
            //UpdateProperties(atmosphereDB);

            // Check if we're doing a full refresh.
            if (!partialRefresh)
            {
                OrbitDB orbitDB = _entity.GetDataBlob <OrbitDB>();
                UpdateProperties(orbitDB);

                MassVolumeDB massVolumeDB = _entity.GetDataBlob <MassVolumeDB>();
                UpdateProperties(massVolumeDB);
            }
        }
        void UpdateDatablob(SystemBodyInfoDB origionalDB, SensorInfoDB sensorInfo)
        {
            Random rng      = new Random(); //TODO: rand should be deterministic.
            float  accuracy = sensorInfo.HighestDetectionQuality.SignalQuality;

            if (sensorInfo.HighestDetectionQuality.SignalQuality > 0.20)
            {
                BodyType = origionalDB.BodyType;
            }
            else
            {
                BodyType = BodyType.Unknown;
            }
            if (sensorInfo.HighestDetectionQuality.SignalQuality > 0.80)
            {
                Tectonics = origionalDB.Tectonics;
            }
            else
            {
                Tectonics = TectonicActivity.Unknown;
            }
            //TODO: #SensorClone, #TMI more random to the rest of it.
            var tilt = SensorProcessorTools.RndSigmoid(origionalDB.AxialTilt, accuracy, rng);

            AxialTilt           = (float)tilt;
            MagneticField       = origionalDB.MagneticField;
            BaseTemperature     = origionalDB.BaseTemperature;
            RadiationLevel      = origionalDB.RadiationLevel;
            AtmosphericDust     = origionalDB.AtmosphericDust;
            SupportsPopulations = origionalDB.SupportsPopulations;
            LengthOfDay         = origionalDB.LengthOfDay;
            Gravity             = origionalDB.Gravity;
            Minerals            = new Dictionary <Guid, MineralDepositInfo>(origionalDB.Minerals); //This really needs to be handled properly
        }
Example #4
0
        /// <summary>
        /// creates an asteroid that will collide with the given entity on the given date.
        /// </summary>
        /// <param name="starSys"></param>
        /// <param name="target"></param>
        /// <param name="collisionDate"></param>
        /// <returns></returns>
        public static Entity CreateAsteroid(StarSystem starSys, Entity target, DateTime collisionDate, double asteroidMass = -1.0)
        {
            //todo rand these a bit.
            double radius = Distance.KmToAU(0.5);

            double mass;

            if (asteroidMass == -1.0)
            {
                mass = 1.5e+12; //about 1.5 billion tonne
            }
            else
            {
                mass = asteroidMass;
            }
            Vector3 velocity = new Vector3(8, 7, 0);

            var position     = new PositionDB(0, 0, 0, Guid.Empty);
            var massVolume   = MassVolumeDB.NewFromMassAndRadius(mass, radius);
            var planetInfo   = new SystemBodyInfoDB();
            var balisticTraj = new NewtonBalisticDB(target.Guid, collisionDate);
            var name         = new NameDB("Ellie");
            var AsteroidDmg  = new AsteroidDamageDB();
            var sensorPfil   = new SensorProfileDB();

            planetInfo.SupportsPopulations = false;
            planetInfo.BodyType            = BodyType.Asteroid;

            Vector3  targetPos       = OrbitProcessor.GetAbsolutePosition_AU(target.GetDataBlob <OrbitDB>(), collisionDate);
            TimeSpan timeToCollision = collisionDate - StaticRefLib.CurrentDateTime;


            Vector3 offset = velocity * timeToCollision.TotalSeconds;

            targetPos -= Distance.KmToAU(offset);
            position.AbsolutePosition_AU = targetPos;
            position.SystemGuid          = starSys.Guid;
            balisticTraj.CurrentSpeed    = velocity;



            var planetDBs = new List <BaseDataBlob>
            {
                position,
                massVolume,
                planetInfo,
                name,
                balisticTraj,
                AsteroidDmg,
                sensorPfil
            };

            Entity newELE = new Entity(starSys, planetDBs);

            return(newELE);
        }
Example #5
0
        public static void UpdateAtmosphere(AtmosphereDB atmoDB, SystemBodyInfoDB bodyDB)
        {
            if (atmoDB.Exists)
            {
                // clear old values.
                atmoDB.Pressure           = 0;
                atmoDB.GreenhousePressure = 0;

                foreach (var gas in atmoDB.Composition)
                {
                    atmoDB.Pressure += gas.Value;

                    // only add a greenhouse gas if it is not frozen or liquid:
                    if (atmoDB.SurfaceTemperature >= gas.Key.BoilingPoint)
                    {
                        // actual greenhouse pressure adjusted by gas GreenhouseEffect.
                        // note that this produces the same affect as in aurora if all GreenhouseEffect bvalue are -1, 0 or 1.
                        atmoDB.GreenhousePressure += (float)gas.Key.GreenhouseEffect * gas.Value;
                    }
                }

                if (bodyDB.BodyType == BodyType.GasDwarf ||
                    bodyDB.BodyType == BodyType.GasGiant ||
                    bodyDB.BodyType == BodyType.IceGiant)
                {
                    // special gas giant stuff, needed because we do not apply greenhouse factor to them:
                    atmoDB.SurfaceTemperature = bodyDB.BaseTemperature * (1 - atmoDB.Albedo);
                    atmoDB.Pressure           = 1; // because thats the definition of the surface of these planets, when
                    // atmosphereic pressure = the pressure of earths atmosphere at its surface (what we call 1 atm).
                }
                else
                {
                    // From Aurora: Greenhouse Factor = 1 + (Atmospheric Pressure /10) + Greenhouse Pressure   (Maximum = 3.0)
                    atmoDB.GreenhouseFactor = (atmoDB.Pressure * 0.035F) + atmoDB.GreenhousePressure;  // note that we do without the extra +1 as it seems to give us better temps.
                    atmoDB.GreenhouseFactor = (float)GMath.Clamp(atmoDB.GreenhouseFactor, -3.0, 3.0);

                    // From Aurora: Surface Temperature in Kelvin = Base Temperature in Kelvin x Greenhouse Factor x Albedo
                    atmoDB.SurfaceTemperature  = Temperature.ToKelvin(bodyDB.BaseTemperature);
                    atmoDB.SurfaceTemperature += atmoDB.SurfaceTemperature * atmoDB.GreenhouseFactor * (float)Math.Pow(1 - atmoDB.Albedo, 0.25);   // We need to raise albedo to the power of 1/4, see: http://en.wikipedia.org/wiki/Stefan%E2%80%93Boltzmann_law
                    atmoDB.SurfaceTemperature  = Temperature.ToCelsius(atmoDB.SurfaceTemperature);
                }
            }
            else
            {
                // simply apply albedo, see here: http://en.wikipedia.org/wiki/Stefan%E2%80%93Boltzmann_law
                atmoDB.Pressure           = 0;
                atmoDB.SurfaceTemperature = Temperature.ToKelvin(bodyDB.BaseTemperature);
                atmoDB.SurfaceTemperature = atmoDB.SurfaceTemperature * (float)Math.Pow(1 - atmoDB.Albedo, 0.25);   // We need to raise albedo to the power of 1/4
            }

            // update the descriptions:
            atmoDB.GenerateDescriptions();
        }
Example #6
0
 public SystemBodyInfoDB(SystemBodyInfoDB systemBodyDB)
 {
     BodyType            = systemBodyDB.BodyType;
     Tectonics           = systemBodyDB.Tectonics;
     AxialTilt           = systemBodyDB.AxialTilt;
     MagneticField       = systemBodyDB.MagneticField;
     BaseTemperature     = systemBodyDB.BaseTemperature;
     RadiationLevel      = systemBodyDB.RadiationLevel;
     AtmosphericDust     = systemBodyDB.AtmosphericDust;
     SupportsPopulations = systemBodyDB.SupportsPopulations;
     LengthOfDay         = systemBodyDB.LengthOfDay;
     Gravity             = systemBodyDB.Gravity;
     Minerals            = new Dictionary <Guid, MineralDepositInfo>(systemBodyDB.Minerals);
 }
        private static bool ColonyGravityIsHabitible(Entity planet, SpeciesDB species)
        {
            SystemBodyInfoDB sysBody       = planet.GetDataBlob <SystemBodyInfoDB>();
            double           planetGravity = sysBody.Gravity;
            double           maxGravity    = species.MaximumGravityConstraint;
            double           minGravity    = species.MinimumGravityConstraint;

            if (planetGravity < minGravity || planetGravity > maxGravity)
            {
                return(false);
            }
            return(true);

            //           throw new NotImplementedException();
        }
        private static double ColonyTemperatureCost(Entity planet, SpeciesDB species)
        {
            SystemBodyInfoDB sysBody = planet.GetDataBlob <SystemBodyInfoDB>();
            double           cost;
            double           idealTemp  = species.BaseTemperature;
            double           planetTemp = sysBody.BaseTemperature; // @todo: find correct temperature after terraforming
            double           tempRange  = species.TemperatureToleranceRange;

            //More Math (the | | signs are for Absolute Value in case you forgot)
            //TempColCost = | Ideal Temp - Current Temp | / TRU (temps in Kelvin)
            // Converting to Kelvin.  It probably doesn't matter, but just in case
            cost = Math.Abs((idealTemp + 273.15) - (planetTemp + 273.15)) / tempRange;

            return(cost);
        }
        /// <summary>
        /// probibly only needs to be done at entity creation, once the bodies mass is set.
        /// </summary>
        /// <returns>The emmision sig.</returns>
        /// <param name="sysBodyInfoDB">Sys body info db.</param>
        /// <param name="massVolDB">Mass vol db.</param>
        internal static void PlanetEmmisionSig(SensorProfileDB profile, SystemBodyInfoDB sysBodyInfoDB, MassVolumeDB massVolDB)
        {
            var        tempDegreesC = sysBodyInfoDB.BaseTemperature;
            var        kelvin       = tempDegreesC + 273.15;
            var        wavelength   = 2.9 * Math.Pow(10, 6) / kelvin;
            var        magnitude    = tempDegreesC / massVolDB.Volume;
            EMWaveForm waveform     = new EMWaveForm()
            {
                WavelengthAverage_nm = wavelength,
                WavelengthMin_nm     = wavelength - 400, //4k angstrom, semi arbitrary number pulled outa my ass from 0min of internet research.
                WavelengthMax_nm     = wavelength + 600
            };

            profile.EmittedEMSpectra.Add(waveform, magnitude);//TODO this may need adjusting to make good balanced detections.
            profile.Reflectivity = sysBodyInfoDB.Albedo;
        }
        /// <summary>
        /// probibly only needs to be done at entity creation, once the bodies mass is set.
        /// </summary>
        /// <returns>The emmision sig.</returns>
        /// <param name="sysBodyInfoDB">Sys body info db.</param>
        /// <param name="massVolDB">Mass vol db.</param>
        internal static void PlanetEmmisionSig(SensorProfileDB profile, SystemBodyInfoDB sysBodyInfoDB, MassVolumeDB massVolDB)
        {
            var    tempDegreesC = sysBodyInfoDB.BaseTemperature;
            var    kelvin       = tempDegreesC + 273.15;
            double b            = 2898000;    //Wien's displacement constant for nanometers.
            var    wavelength   = b / kelvin; //Wien's displacement law https://en.wikipedia.org/wiki/Wien%27s_displacement_law


            var cop         = 5.670373E-8;
            var emisivity   = 1 - sysBodyInfoDB.Albedo;
            var j           = emisivity * cop * Math.Pow(kelvin, 4);
            var surfaceArea = 4 * Math.PI * massVolDB.RadiusInM * massVolDB.RadiusInM;
            var magnitude   = j * surfaceArea * 0.001;

            //-400 & +600, semi arbitrary number pulled outa my ass from 0min of internet research.
            EMWaveForm waveform = new EMWaveForm(wavelength - 400, wavelength, wavelength + 600);


            profile.EmittedEMSpectra.Add(waveform, magnitude);//TODO this may need adjusting to make good balanced detections.
            profile.Reflectivity = sysBodyInfoDB.Albedo;
        }
Example #11
0
        private void UpdateProperties([NotNull] SystemBodyInfoDB systemBodyDB, bool partialRefresh)
        {
            if (systemBodyDB == null)
            {
                throw new ArgumentNullException("systemBodyDB");
            }

            if (!partialRefresh)
            {
                // Full Refresh. Update unchanging variables.
                PlanetType      = systemBodyDB.BodyType.ToString();
                AxialTilt       = systemBodyDB.AxialTilt;
                BaseTemperature = systemBodyDB.BaseTemperature;
                LengthOfDay     = systemBodyDB.LengthOfDay;
                MagneticField   = systemBodyDB.MagneticField;
                Tectonics       = systemBodyDB.Tectonics.ToString();
            }
            // Unused currently. TODO: Review if this should be moved to AtmosphereDB in the game lib.
            // AtmosphericDust = systemBodyDB.AtmosphericDust;
            // RadiationLevel = systemBodyDB.RadiationLevel;
            // SupportsPopulation = systemBodyDB.SupportsPopulation;
            // Minerals = systemBodyDB.Minerals;
        }
Example #12
0
        /// <summary>
        /// cost should increase with composition. there has to be a more efficent way of doing this too.
        /// </summary>
        /// <param name="planet"></param>
        /// <param name="species"></param>
        /// <returns></returns>
        private static double ColonyToxicityCost(Entity planet, SpeciesDB species)
        {
            double           cost          = 1.0;
            double           O2Pressure    = 0.0;
            double           totalPressure = 0.0;
            SystemBodyInfoDB sysBody       = planet.GetDataBlob <SystemBodyInfoDB>();
            AtmosphereDB     atmosphere    = planet.GetDataBlob <AtmosphereDB>();

            Dictionary <AtmosphericGasSD, float> atmosphereComp = atmosphere.Composition;

            foreach (KeyValuePair <AtmosphericGasSD, float> kvp in atmosphereComp)
            {
                string symbol = kvp.Key.ChemicalSymbol;
                totalPressure += kvp.Value;
                if (kvp.Key.IsToxic)
                {
                    //Toxic Gasses(CC = 2): Hydrogen(H2), Methane(CH4), Ammonia(NH3), Carbon Monoxide(CO), Nitrogen Monoxide(NO), Hydrogen Sulfide(H2S), Nitrogen Dioxide(NO2), Sulfur Dioxide(SO2)
                    //Toxic Gasses(CC = 3): Chlorine(Cl2), Florine(F2), Bromine(Br2), and Iodine(I2)
                    //Toxic Gasses at 30% or greater of atm: Oxygen(O2) *

                    if (symbol == "H2" || symbol == "CH4" || symbol == "NH3" || symbol == "CO" || symbol == "NO" || symbol == "H2S" || symbol == "NO2" || symbol == "SO2")
                    {
                        cost = Math.Max(cost, 2.0);
                    }
                    if (symbol == "Cl2" || symbol == "F2" || symbol == "Br2" || symbol == "I2")
                    {
                        cost = Math.Max(cost, 3.0);
                    }
                }
                if (symbol == "O")
                {
                    O2Pressure = kvp.Value;
                }
            }

            return(cost);
        }
Example #13
0
        private static SpeciesDB CreateSpeciesDB_FromPlanet(Entity planetEntity, int?seed = null)
        {
            Random rnd;

            if (seed != null)
            {
                rnd = new Random((int)seed);
            }
            else
            {
                rnd = new Random();
            }

            MassVolumeDB     masvolinfo  = planetEntity.GetDataBlob <MassVolumeDB>();
            SystemBodyInfoDB sysbodyinfo = planetEntity.GetDataBlob <SystemBodyInfoDB>();
            AtmosphereDB     atmoinfo    = planetEntity.GetDataBlob <AtmosphereDB>();


            //throw new NotImplementedException();
            double    baseGravity = masvolinfo.SurfaceGravity;
            double    minimumGravityConstraint     = 0.1;//rnd.Next(planetInfo.SurfaceGravity, 0.1);
            double    maximumGravityConstraint     = 1.9;
            double    basePressure                 = atmoinfo.Pressure;
            double    minimumPressureConstraint    = 0.4;
            double    maximumPressureConstraint    = 4.0;
            double    baseTemperature              = sysbodyinfo.BaseTemperature;
            double    minimumTemperatureConstraint = -15.0;
            double    maximumTemperatureConstraint = 45.0;
            SpeciesDB species = new SpeciesDB(baseGravity,
                                              minimumGravityConstraint, maximumGravityConstraint,
                                              basePressure, minimumPressureConstraint,
                                              maximumPressureConstraint, baseTemperature,
                                              minimumTemperatureConstraint, maximumTemperatureConstraint);

            return(species);
        }
Example #14
0
        public StarSystem CreateTestSystem(Game game, int x = 0, int y = 0)
        {
            StarSystem sol = new StarSystem(game, "something", -1);

            Entity sun = _starFactory.CreateStar(sol, GameConstants.Units.SolarMassInKG, GameConstants.Units.SolarRadiusInAu, 4.6E9, "G", 5778, 1, SpectralType.G, "something");

            sun.GetDataBlob <PositionDB>().X_AU += x;
            sun.GetDataBlob <PositionDB>().Y_AU += x;

            MassVolumeDB sunMVDB = sun.GetDataBlob <MassVolumeDB>();

            SystemBodyInfoDB mercuryBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true, Albedo = 0.068f
            };                                                                                                                                      //Albedo = 0.068f
            MassVolumeDB mercuryMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(3.3022E23, Distance.KmToAU(2439.7));
            NameDB       mercuryNameDB       = new NameDB("LOLXDWTF");
            double       mercurySemiMajAxis  = 0.387098;
            double       mercuryEccentricity = 0.205630;
            double       mercuryInclination  = 0;
            double       mercuryLoAN         = 48.33167;
            double       mercuryLoP          = 77.45645;
            double       mercuryMeanLongd    = 252.25084;
            OrbitDB      mercuryOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, mercuryMVDB.MassDry, mercurySemiMajAxis, mercuryEccentricity, mercuryInclination, mercuryLoAN, mercuryLoP, mercuryMeanLongd, GalaxyGen.Settings.J2000);
            PositionDB   mercuryPositionDB   = new PositionDB(OrbitProcessor.GetPosition_AU(mercuryOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun);
            //AtmosphereDB mercuryAtmo = new AtmosphereDB();
            SensorProfileDB sensorProfile = new SensorProfileDB();

            mercuryPositionDB.X_AU += x;
            mercuryPositionDB.Y_AU += x;
            Entity mercury = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, mercuryPositionDB, mercuryBodyDB, mercuryMVDB, mercuryNameDB, mercuryOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, mercury);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, mercuryBodyDB, mercuryMVDB);

            SystemBodyInfoDB venusBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true, Albedo = 0.77f
            };
            MassVolumeDB venusMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(4.8676E24, Distance.KmToAU(6051.8));
            NameDB       venusNameDB       = new NameDB("AYLMAOROFL");
            double       venusSemiMajAxis  = 0.72333199;
            double       venusEccentricity = 0.00677323;
            double       venusInclination  = 0;
            double       venusLoAN         = 76.68069;
            double       venusLoP          = 131.53298;
            double       venusMeanLongd    = 181.97973;
            OrbitDB      venusOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, venusMVDB.MassDry, venusSemiMajAxis, venusEccentricity, venusInclination, venusLoAN, venusLoP, venusMeanLongd, GalaxyGen.Settings.J2000);
            PositionDB   venusPositionDB   = new PositionDB(OrbitProcessor.GetPosition_AU(venusOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun);

            sensorProfile = new SensorProfileDB();
            Entity venus = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, venusPositionDB, venusBodyDB, venusMVDB, venusNameDB, venusOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, venus);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, venusBodyDB, venusMVDB);

            SystemBodyInfoDB earthBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true, Albedo = 0.306f
            };
            MassVolumeDB earthMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(5.9726E24, Distance.KmToAU(6378.1));
            NameDB       earthNameDB       = new NameDB("OMG");
            double       earthSemiMajAxis  = 1.00000011;
            double       earthEccentricity = 0.01671022;
            double       earthInclination  = 0;
            double       earthLoAN         = -11.26064;
            double       earthLoP          = 102.94719;
            double       earthMeanLongd    = 100.46435;
            OrbitDB      earthOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, earthMVDB.MassDry, earthSemiMajAxis, earthEccentricity, earthInclination, earthLoAN, earthLoP, earthMeanLongd, GalaxyGen.Settings.J2000);

            earthBodyDB.Tectonics = TectonicActivity.EarthLike;
            PositionDB earthPositionDB = new PositionDB(OrbitProcessor.GetPosition_AU(earthOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun);
            Dictionary <AtmosphericGasSD, float> atmoGasses = new Dictionary <AtmosphericGasSD, float>();

            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(6), 0.78f);
            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(9), 0.12f);
            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(11), 0.01f);
            AtmosphereDB earthAtmosphereDB = new AtmosphereDB(1f, true, 71, 1f, 1f, 57.2f, atmoGasses); //TODO what's our greenhouse factor an pressure?

            sensorProfile = new SensorProfileDB();
            Entity earth = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, earthPositionDB, earthBodyDB, earthMVDB, earthNameDB, earthOrbitDB, earthAtmosphereDB
            });

            _systemBodyFactory.HomeworldMineralGeneration(game.StaticData, sol, earth);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, earthBodyDB, earthMVDB);


            SystemBodyInfoDB lunaBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Moon, SupportsPopulations = true
            };
            MassVolumeDB lunaMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(0.073E24, Distance.KmToAU(1738.14));
            NameDB       lunaNameDB       = new NameDB("NOWAY");
            double       lunaSemiMajAxis  = Distance.KmToAU(0.3844E6);
            double       lunaEccentricity = 0.0549;
            double       lunaInclination  = 0;//5.1;
            // Next three values are unimportant. Luna's LoAN and AoP regress/progress by one revolution every 18.6/8.85 years respectively.
            // Our orbit code it not advanced enough to deal with LoAN/AoP regression/progression.
            double     lunaLoAN        = 125.08;
            double     lunaAoP         = 318.0634;
            double     lunaMeanAnomaly = 115.3654;
            OrbitDB    lunaOrbitDB     = OrbitDB.FromAsteroidFormat(earth, earthMVDB.MassDry, lunaMVDB.MassDry, lunaSemiMajAxis, lunaEccentricity, lunaInclination, lunaLoAN, lunaAoP, lunaMeanAnomaly, GalaxyGen.Settings.J2000);
            PositionDB lunaPositionDB  = new PositionDB(OrbitProcessor.GetPosition_AU(lunaOrbitDB, StaticRefLib.CurrentDateTime) + earthPositionDB.AbsolutePosition_AU, sol.Guid, earth);

            sensorProfile = new SensorProfileDB();
            Entity luna = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, lunaPositionDB, lunaBodyDB, lunaMVDB, lunaNameDB, lunaOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, luna);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, lunaBodyDB, lunaMVDB);


            SystemBodyInfoDB halleysBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Comet, SupportsPopulations = false, Albedo = 0.04f
            };                                                                                                                                 //Albedo = 0.04f
            MassVolumeDB halleysMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(2.2e14, Distance.KmToAU(11));
            NameDB       halleysNameDB       = new NameDB("ASSHOLE");
            double       halleysSemiMajAxis  = 17.834;                                                                                                     //AU
            double       halleysEccentricity = 0.96714;
            double       halleysInclination  = 180;                                                                                                        //162.26° note retrograde orbit.
            double       halleysLoAN         = 58.42;                                                                                                      //°
            double       halleysAoP          = 111.33;                                                                                                     //°
            double       halleysMeanAnomaly  = 38.38;                                                                                                      //°
            OrbitDB      halleysOrbitDB      = OrbitDB.FromAsteroidFormat(sun, sunMVDB.MassDry, halleysMVDB.MassDry, halleysSemiMajAxis, halleysEccentricity, halleysInclination, halleysLoAN, halleysAoP, halleysMeanAnomaly, new System.DateTime(1994, 2, 17));
            PositionDB   halleysPositionDB   = new PositionDB(OrbitProcessor.GetPosition_AU(halleysOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun); // + earthPositionDB.AbsolutePosition_AU, sol.ID);

            sensorProfile = new SensorProfileDB();
            Entity halleysComet = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, halleysPositionDB, halleysBodyDB, halleysMVDB, halleysNameDB, halleysOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, halleysComet);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, halleysBodyDB, halleysMVDB);

            JPSurveyFactory.GenerateJPSurveyPoints(sol);

            game.GameMasterFaction.GetDataBlob <FactionInfoDB>().KnownSystems.Add(sol.Guid);
            return(sol);
        }
Example #15
0
        /// <summary>
        /// Creates our own solar system.
        /// This probibly needs to be Json! (since we're getting atmo stuff)
        /// Adds sol to game.StarSystems.
        /// </summary>
        public StarSystem CreateSol(Game game)
        {
            // WIP Function. Not complete.
            StarSystem sol = new StarSystem(game, "Sol", -1);

            Entity sun = _starFactory.CreateStar(sol, GameConstants.Units.SolarMassInKG, GameConstants.Units.SolarRadiusInAu, 4.6E9, "G", 5778, 1, SpectralType.G, "Sol");

            MassVolumeDB sunMVDB = sun.GetDataBlob <MassVolumeDB>();

            SystemBodyInfoDB mercuryBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true, Albedo = 0.068f
            };                                                                                                                                      //Albedo = 0.068f
            MassVolumeDB mercuryMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(3.3022E23, Distance.KmToAU(2439.7));
            NameDB       mercuryNameDB       = new NameDB("Mercury");
            double       mercurySemiMajAxis  = 0.387098;
            double       mercuryEccentricity = 0.205630;
            double       mercuryInclination  = 0;
            double       mercuryLoAN         = 48.33167;
            double       mercuryLoP          = 77.45645;
            double       mercuryMeanLongd    = 252.25084;
            OrbitDB      mercuryOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, mercuryMVDB.MassDry, mercurySemiMajAxis, mercuryEccentricity, mercuryInclination, mercuryLoAN, mercuryLoP, mercuryMeanLongd, GalaxyGen.Settings.J2000);

            mercuryBodyDB.BaseTemperature = (float)SystemBodyFactory.CalculateBaseTemperatureOfBody(sun, mercuryOrbitDB);
            PositionDB mercuryPositionDB = new PositionDB(OrbitProcessor.GetPosition_AU(mercuryOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun);
            //AtmosphereDB mercuryAtmo = new AtmosphereDB();
            SensorProfileDB sensorProfile = new SensorProfileDB();
            Entity          mercury       = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, mercuryPositionDB, mercuryBodyDB, mercuryMVDB, mercuryNameDB, mercuryOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, mercury);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, mercuryBodyDB, mercuryMVDB);

            SystemBodyInfoDB venusBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true, Albedo = 0.77f
            };
            MassVolumeDB venusMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(4.8676E24, Distance.KmToAU(6051.8));
            NameDB       venusNameDB       = new NameDB("Venus");
            double       venusSemiMajAxis  = 0.72333199;
            double       venusEccentricity = 0.00677323;
            double       venusInclination  = 0;
            double       venusLoAN         = 76.68069;
            double       venusLoP          = 131.53298;
            double       venusMeanLongd    = 181.97973;

            OrbitDB venusOrbitDB = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, venusMVDB.MassDry, venusSemiMajAxis, venusEccentricity, venusInclination, venusLoAN, venusLoP, venusMeanLongd, GalaxyGen.Settings.J2000);

            venusBodyDB.BaseTemperature = (float)SystemBodyFactory.CalculateBaseTemperatureOfBody(sun, venusOrbitDB);
            PositionDB venusPositionDB = new PositionDB(OrbitProcessor.GetPosition_AU(venusOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun);

            sensorProfile = new SensorProfileDB();
            Entity venus = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, venusPositionDB, venusBodyDB, venusMVDB, venusNameDB, venusOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, venus);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, venusBodyDB, venusMVDB);

            SystemBodyInfoDB earthBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true, Albedo = 0.306f
            };
            MassVolumeDB earthMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(5.9726E24, Distance.KmToAU(6378.1));
            NameDB       earthNameDB       = new NameDB("Earth");
            double       earthSemiMajAxis  = 1.00000011;
            double       earthEccentricity = 0.01671022;
            double       earthInclination  = 0;
            double       earthLoAN         = -11.26064;
            double       earthLoP          = 102.94719;
            double       earthMeanLongd    = 100.46435;
            OrbitDB      earthOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, earthMVDB.MassDry, earthSemiMajAxis, earthEccentricity, earthInclination, earthLoAN, earthLoP, earthMeanLongd, GalaxyGen.Settings.J2000);

            earthBodyDB.BaseTemperature = (float)SystemBodyFactory.CalculateBaseTemperatureOfBody(sun, earthOrbitDB);
            earthBodyDB.Tectonics       = TectonicActivity.EarthLike;
            PositionDB earthPositionDB = new PositionDB(OrbitProcessor.GetPosition_AU(earthOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun);
            Dictionary <AtmosphericGasSD, float> atmoGasses = new Dictionary <AtmosphericGasSD, float>();

            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(6), 0.78f);
            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(9), 0.12f);
            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(11), 0.01f);
            AtmosphereDB earthAtmosphereDB = new AtmosphereDB(1f, true, 71, 1f, 1f, 57.2f, atmoGasses); //TODO what's our greenhouse factor an pressure?

            sensorProfile = new SensorProfileDB();
            Entity earth = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, earthPositionDB, earthBodyDB, earthMVDB, earthNameDB, earthOrbitDB, earthAtmosphereDB
            });

            _systemBodyFactory.HomeworldMineralGeneration(game.StaticData, sol, earth);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, earthBodyDB, earthMVDB);


            SystemBodyInfoDB lunaBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Moon, SupportsPopulations = true
            };
            MassVolumeDB lunaMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(0.073E24, Distance.KmToAU(1738.14));
            NameDB       lunaNameDB       = new NameDB("Luna");
            double       lunaSemiMajAxis  = Distance.KmToAU(0.3844E6);
            double       lunaEccentricity = 0.0549;
            double       lunaInclination  = 0;//5.1;
            // Next three values are unimportant. Luna's LoAN and AoP regress/progress by one revolution every 18.6/8.85 years respectively.
            // Our orbit code it not advanced enough to deal with LoAN/AoP regression/progression.
            double  lunaLoAN        = 125.08;
            double  lunaAoP         = 318.0634;
            double  lunaMeanAnomaly = 115.3654;
            OrbitDB lunaOrbitDB     = OrbitDB.FromAsteroidFormat(earth, earthMVDB.MassDry, lunaMVDB.MassDry, lunaSemiMajAxis, lunaEccentricity, lunaInclination, lunaLoAN, lunaAoP, lunaMeanAnomaly, GalaxyGen.Settings.J2000);

            lunaBodyDB.BaseTemperature = (float)SystemBodyFactory.CalculateBaseTemperatureOfBody(sun, earthOrbitDB); //yes, using earth orbit here, since this is the DB it calculates the average distance from.

            PositionDB lunaPositionDB = new PositionDB(OrbitProcessor.GetPosition_AU(lunaOrbitDB, StaticRefLib.CurrentDateTime) + earthPositionDB.AbsolutePosition_AU, sol.Guid, earth);

            sensorProfile = new SensorProfileDB();
            Entity luna = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, lunaPositionDB, lunaBodyDB, lunaMVDB, lunaNameDB, lunaOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, luna);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, lunaBodyDB, lunaMVDB);


            SystemBodyInfoDB marsBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true, Albedo = 0.25f
            };
            MassVolumeDB marsMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(0.64174E24, Distance.KmToAU(3396.2));
            NameDB       marsNameDB       = new NameDB("Mars");
            double       marsSemiMajAxis  = Distance.KmToAU(227.92E6);
            double       marsEccentricity = 0.0934; //wiki says .0934
            double       marsInclination  = 0;      //1.85;
            double       marsLoAN         = 49.57854;
            double       marsAoP          = 336.04084;
            double       marsMeanLong     = 355.45332;
            OrbitDB      marsOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, marsMVDB.MassDry, marsSemiMajAxis, marsEccentricity, marsInclination, marsLoAN, marsAoP, marsMeanLong, GalaxyGen.Settings.J2000);

            marsBodyDB.BaseTemperature = (float)SystemBodyFactory.CalculateBaseTemperatureOfBody(sun, marsOrbitDB);
            Dictionary <AtmosphericGasSD, float> marsAtmoGasses = new Dictionary <AtmosphericGasSD, float>();

            marsAtmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(12), 0.95f * 0.01f);   // C02% * Mars Atms
            marsAtmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(6), 0.027f * 0.01f);   // N% * Mars Atms
            marsAtmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(9), 0.007f * 0.01f);   // O% * Mars Atms
            marsAtmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(11), 0.016f * 0.01f);  // Ar% * Mars Atms
            AtmosphereDB marsAtmo       = new AtmosphereDB(0.087f, false, 0, 0, 0, -55, marsAtmoGasses);
            PositionDB   marsPositionDB = new PositionDB(OrbitProcessor.GetPosition_AU(marsOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun);

            sensorProfile = new SensorProfileDB();
            Entity mars = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, marsPositionDB, marsBodyDB, marsMVDB, marsNameDB, marsOrbitDB, marsAtmo
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, mars);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, marsBodyDB, marsMVDB);


            SystemBodyInfoDB halleysBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Comet, SupportsPopulations = false, Albedo = 0.04f
            };                                                                                                                                 //Albedo = 0.04f
            MassVolumeDB halleysMVDB         = MassVolumeDB.NewFromMassAndRadius_AU(2.2e14, Distance.KmToAU(11));
            NameDB       halleysNameDB       = new NameDB("Halleys Comet");
            double       halleysSemiMajAxis  = 17.834; //AU
            double       halleysEccentricity = 0.96714;
            double       halleysInclination  = 180;    //162.26° note retrograde orbit.
            double       halleysLoAN         = 58.42;  //°
            double       halleysAoP          = 111.33; //°
            double       halleysMeanAnomaly  = 38.38;  //°
            OrbitDB      halleysOrbitDB      = OrbitDB.FromAsteroidFormat(sun, sunMVDB.MassDry, halleysMVDB.MassDry, halleysSemiMajAxis, halleysEccentricity, halleysInclination, halleysLoAN, halleysAoP, halleysMeanAnomaly, new System.DateTime(1994, 2, 17));

            halleysBodyDB.BaseTemperature = (float)SystemBodyFactory.CalculateBaseTemperatureOfBody(sun, halleysOrbitDB);
            PositionDB halleysPositionDB = new PositionDB(OrbitProcessor.GetPosition_AU(halleysOrbitDB, StaticRefLib.CurrentDateTime), sol.Guid, sun); // + earthPositionDB.AbsolutePosition_AU, sol.ID);

            sensorProfile = new SensorProfileDB();
            Entity halleysComet = new Entity(sol, new List <BaseDataBlob> {
                sensorProfile, halleysPositionDB, halleysBodyDB, halleysMVDB, halleysNameDB, halleysOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, halleysComet);
            SensorProcessorTools.PlanetEmmisionSig(sensorProfile, halleysBodyDB, halleysMVDB);

            /*
             *
             * SystemBody Jupiter = new SystemBody(sun, SystemBody.PlanetType.GasGiant);
             * Jupiter.Name = "Jupiter";
             * Jupiter.Orbit = Orbit.FromMajorPlanetFormat(1898.3E24, sun.Orbit.Mass, 5.20336301, 0.04839266, 1.30530, 100.55615, 14.75385, 34.40438, GalaxyGen.J2000);
             * Jupiter.Radius = Distance.ToAU(71492);
             * Jupiter.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Jupiter.Position.System = Sol;
             * Jupiter.Position.X = x;
             * Jupiter.Position.Y = y;
             * sun.Planets.Add(Jupiter);
             *
             * SystemBody Saturn = new SystemBody(sun, SystemBody.PlanetType.GasGiant);
             * Saturn.Name = "Saturn";
             * Saturn.Orbit = Orbit.FromMajorPlanetFormat(568.36E24, sun.Orbit.Mass, 9.53707032, 0.05415060, 2.48446, 113.71504, 92.43194, 49.94432, GalaxyGen.J2000);
             * Saturn.Radius = Distance.ToAU(60268);
             * Saturn.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Saturn.Position.System = Sol;
             * Saturn.Position.X = x;
             * Saturn.Position.Y = y;
             * sun.Planets.Add(Saturn);
             *
             * SystemBody Uranus = new SystemBody(sun, SystemBody.PlanetType.IceGiant);
             * Uranus.Name = "Uranus";
             * Uranus.Orbit = Orbit.FromMajorPlanetFormat(86.816E24, sun.Orbit.Mass, 19.19126393, 0.04716771, 0.76986, 74.22988, 170.96424, 313.23218, GalaxyGen.J2000);
             * Uranus.Radius = Distance.ToAU(25559);
             * Uranus.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Uranus.Position.System = Sol;
             * Uranus.Position.X = x;
             * Uranus.Position.Y = y;
             * sun.Planets.Add(Uranus);
             *
             * SystemBody Neptune = new SystemBody(sun, SystemBody.PlanetType.IceGiant);
             * Neptune.Name = "Neptune";
             * Neptune.Orbit = Orbit.FromMajorPlanetFormat(102E24, sun.Orbit.Mass, Distance.ToAU(4495.1E6), 0.011, 1.8, 131.72169, 44.97135, 304.88003, GalaxyGen.J2000);
             * Neptune.Radius = Distance.ToAU(24764);
             * Neptune.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Neptune.Position.System = Sol;
             * Neptune.Position.X = x;
             * Neptune.Position.Y = y;
             * sun.Planets.Add(Neptune);
             *
             * SystemBody Pluto = new SystemBody(sun, SystemBody.PlanetType.DwarfPlanet);
             * Pluto.Name = "Pluto";
             * Pluto.Orbit = Orbit.FromMajorPlanetFormat(0.0131E24, sun.Orbit.Mass, Distance.ToAU(5906.38E6), 0.24880766, 17.14175, 110.30347, 224.06676, 238.92881, GalaxyGen.J2000);
             * Pluto.Radius = Distance.ToAU(1195);
             * Pluto.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Pluto.Position.System = Sol;
             * Pluto.Position.X = x;
             * Pluto.Position.Y = y;
             * sun.Planets.Add(Pluto);
             *
             * GenerateJumpPoints(Sol);
             *
             * // Clean up cached RNG:
             * m_RNG = null;
             * GameState.Instance.StarSystems.Add(Sol);
             * GameState.Instance.StarSystemCurrentIndex++;
             */

            /*
             * double planetSemiMajAxis = 0.387098;
             * double planetEccentricity = 0.205630;
             * double planetInclination = 0;
             * double planetLoAN = 0;//48.33167;
             * double planetLoP = 0;//77.45645;
             * double planetMeanLongd = 252.25084;
             *
             * EMWaveForm waveform;
             *
             * for (int i = 0; i < 8; i++)
             * {
             *  NameDB planetNameDB = new NameDB("planetE" + i);
             *
             *  SystemBodyInfoDB planetBodyDB = new SystemBodyInfoDB { BodyType = BodyType.Terrestrial, SupportsPopulations = true };
             *  MassVolumeDB planetMVDB = MassVolumeDB.NewFromMassAndRadius_AU(3.3022E23, Distance.KmToAU(2439.7));
             *  PositionDB planetPositionDB = new PositionDB(sol.ID);
             *  planetEccentricity = i * 2 / 16.0;
             *  OrbitDB planetOrbitDB = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.Mass, planetMVDB.Mass, planetSemiMajAxis, planetEccentricity, planetInclination, planetLoAN, planetLoP, planetMeanLongd, GalaxyGen.Settings.J2000);
             *  planetPositionDB.AbsolutePosition = OrbitProcessor.GetPosition(planetOrbitDB, game.CurrentDateTime);
             *
             *  waveform = new EMWaveForm()
             *  {
             *      WavelengthAverage_nm = 600,
             *      WavelengthMin_nm = 600 - 400, //4k angstrom, semi arbitrary number pulled outa my ass from 0min of internet research.
             *      WavelengthMax_nm = 600 + 600
             *  };
             *
             *  sensorProfile = new SensorProfileDB();
             *  sensorProfile.EmittedEMSpectra.Add(waveform, 3.827e23);
             *  Entity planet = new Entity(sol, new List<BaseDataBlob> { sensorProfile, planetPositionDB, planetBodyDB, planetMVDB, planetNameDB, planetOrbitDB });
             * }
             *
             * planetEccentricity = 0.9;
             * for (int i = 0; i < 8; i++)
             * {
             *  NameDB planetNameDB = new NameDB("planetL" + i);
             *  SystemBodyInfoDB planetBodyDB = new SystemBodyInfoDB { BodyType = BodyType.Terrestrial, SupportsPopulations = true };
             *  MassVolumeDB planetMVDB = MassVolumeDB.NewFromMassAndRadius_AU(3.3022E23, Distance.KmToAU(2439.7));
             *  PositionDB planetPositionDB = new PositionDB(sol.ID);
             *  planetLoP = i * 15;
             *  OrbitDB planetOrbitDB = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.Mass, planetMVDB.Mass, planetSemiMajAxis, planetEccentricity, planetInclination, planetLoAN, planetLoP, planetMeanLongd, GalaxyGen.Settings.J2000);
             *  planetPositionDB.AbsolutePosition = OrbitProcessor.GetPosition(planetOrbitDB, game.CurrentDateTime);
             *
             *  waveform = new EMWaveForm()
             *  {
             *      WavelengthAverage_nm = 600,
             *      WavelengthMin_nm = 600 - 400, //4k angstrom, semi arbitrary number pulled outa my ass from 0min of internet research.
             *      WavelengthMax_nm = 600 + 600
             *  };
             *
             *  sensorProfile = new SensorProfileDB();
             *  sensorProfile.EmittedEMSpectra.Add(waveform, 3.827e23);
             *  Entity planet = new Entity(sol, new List<BaseDataBlob> {sensorProfile, planetPositionDB, planetBodyDB, planetMVDB, planetNameDB, planetOrbitDB });
             * }
             */

            JPSurveyFactory.GenerateJPSurveyPoints(sol);

            game.GameMasterFaction.GetDataBlob <FactionInfoDB>().KnownSystems.Add(sol.Guid);
            return(sol);
        }
Example #16
0
        public static Entity CreateAsteroid4(Vector3 position, OrbitDB origOrbit, DateTime atDateTime, double asteroidMass = -1.0)
        {
            //todo rand these a bit.
            double radius = Distance.KmToAU(0.5);

            double mass;

            if (asteroidMass == -1.0)
            {
                mass = 1.5e+12; //about 1.5 billion tonne
            }
            else
            {
                mass = asteroidMass;
            }

            var     speed    = Distance.KmToAU(40);
            Vector3 velocity = new Vector3(speed, 0, 0);


            var massVolume  = MassVolumeDB.NewFromMassAndRadius_AU(mass, radius);
            var planetInfo  = new SystemBodyInfoDB();
            var name        = new NameDB("Ellie");
            var AsteroidDmg = new AsteroidDamageDB();

            AsteroidDmg.FractureChance = new PercentValue(0.75f);
            var dmgPfl     = EntityDamageProfileDB.AsteroidDamageProfile(massVolume.Volume_km3, massVolume.Density, massVolume.RadiusInM, 50);
            var sensorPfil = new SensorProfileDB();

            planetInfo.SupportsPopulations = false;
            planetInfo.BodyType            = BodyType.Asteroid;


            var parent     = origOrbit.Parent;
            var parentMass = parent.GetDataBlob <MassVolumeDB>().Mass;
            var myMass     = massVolume.Mass;

            double sgp = GameConstants.Science.GravitationalConstant * (parentMass + myMass) / 3.347928976e33;
            //OrbitDB orbit = OrbitDB.FromVector(parent, myMass, parentMass, sgp, position, velocity, atDateTime);
            //OrbitDB orbit = (OrbitDB)origOrbit.Clone();
            OrbitDB orbit = new OrbitDB(origOrbit.Parent, parentMass, myMass, origOrbit.SemiMajorAxis_AU,
                                        origOrbit.Eccentricity, origOrbit.Inclination_Degrees, origOrbit.LongitudeOfAscendingNode_Degrees,
                                        origOrbit.ArgumentOfPeriapsis_Degrees, origOrbit.MeanMotion_DegreesSec, origOrbit.Epoch);

            var posDB = new PositionDB(position.X, position.Y, position.Z, parent.Manager.ManagerGuid, parent);


            var planetDBs = new List <BaseDataBlob>
            {
                posDB,
                massVolume,
                planetInfo,
                name,
                orbit,
                AsteroidDmg,
                dmgPfl,
                sensorPfil
            };

            Entity newELE = new Entity(origOrbit.OwningEntity.Manager, planetDBs);

            return(newELE);
        }
Example #17
0
        /// <summary>
        /// creates an asteroid that will collide with the given entity on the given date.
        /// </summary>
        /// <param name="starSys"></param>
        /// <param name="target"></param>
        /// <param name="collisionDate"></param>
        /// <returns></returns>
        public static Entity CreateAsteroid(StarSystem starSys, Entity target, DateTime collisionDate, double asteroidMass = -1.0)
        {
            //todo rand these a bit.
            double radius = Distance.KmToAU(0.5);

            double mass;

            if (asteroidMass < 0)
            {
                mass = 1.5e+12; //about 1.5 billion tonne
            }
            else
            {
                mass = asteroidMass;
            }

            var     speed    = 40000;
            Vector3 velocity = new Vector3(speed, 0, 0);


            var massVolume  = MassVolumeDB.NewFromMassAndRadius_AU(mass, radius);
            var planetInfo  = new SystemBodyInfoDB();
            var name        = new NameDB("Ellie");
            var AsteroidDmg = new AsteroidDamageDB();

            AsteroidDmg.FractureChance = new PercentValue(0.75f);
            var dmgPfl     = EntityDamageProfileDB.AsteroidDamageProfile(massVolume.Volume_km3, massVolume.Density, massVolume.RadiusInM, 50);
            var sensorPfil = new SensorProfileDB();

            planetInfo.SupportsPopulations = false;
            planetInfo.BodyType            = BodyType.Asteroid;

            Vector3  targetPos       = OrbitProcessor.GetAbsolutePosition_m(target.GetDataBlob <OrbitDB>(), collisionDate);
            TimeSpan timeToCollision = collisionDate - StaticRefLib.CurrentDateTime;


            var parent     = target.GetDataBlob <OrbitDB>().Parent;
            var parentMass = parent.GetDataBlob <MassVolumeDB>().Mass;
            var myMass     = massVolume.Mass;

            double  sgp   = OrbitMath.CalculateStandardGravityParameterInM3S2(myMass, parentMass);
            OrbitDB orbit = OrbitDB.FromVector(parent, myMass, parentMass, sgp, targetPos, velocity, collisionDate);

            var currentpos = OrbitProcessor.GetAbsolutePosition_AU(orbit, StaticRefLib.CurrentDateTime);
            var posDB      = new PositionDB(currentpos.X, currentpos.Y, currentpos.Z, parent.Manager.ManagerGuid, parent);


            var planetDBs = new List <BaseDataBlob>
            {
                posDB,
                massVolume,
                planetInfo,
                name,
                orbit,
                AsteroidDmg,
                dmgPfl,
                sensorPfil
            };

            Entity newELE = new Entity(starSys, planetDBs);

            return(newELE);
        }
Example #18
0
        public static Entity CreateAsteroid2(StarSystem starSys, Entity target, DateTime collisionDate, double asteroidMass = -1.0)
        {
            //todo rand these a bit.
            double radius = Distance.KmToAU(0.5);

            double mass;

            if (asteroidMass == -1.0)
            {
                mass = 1.5e+12; //about 1.5 billion tonne
            }
            else
            {
                mass = asteroidMass;
            }
            Vector3 velocity = new Vector3(8, 7, 0);

            var position     = new PositionDB(0, 0, 0, Guid.Empty);
            var massVolume   = MassVolumeDB.NewFromMassAndRadius(mass, radius);
            var planetInfo   = new SystemBodyInfoDB();
            var balisticTraj = new NewtonBalisticDB(target.Guid, collisionDate);
            var name         = new NameDB("Ellie");
            var AsteroidDmg  = new AsteroidDamageDB();
            var sensorPfil   = new SensorProfileDB();

            planetInfo.SupportsPopulations = false;
            planetInfo.BodyType            = BodyType.Asteroid;

            Vector3  targetPos       = OrbitProcessor.GetAbsolutePosition_AU(target.GetDataBlob <OrbitDB>(), collisionDate);
            TimeSpan timeToCollision = collisionDate - StaticRefLib.CurrentDateTime;


            Vector3 offset = velocity * timeToCollision.TotalSeconds;

            targetPos -= Distance.KmToAU(offset);
            position.AbsolutePosition_AU = targetPos;
            position.SystemGuid          = starSys.Guid;
            balisticTraj.CurrentSpeed    = velocity;


            var parent          = target.GetDataBlob <OrbitDB>().Parent;
            var parentMass      = parent.GetDataBlob <MassVolumeDB>().Mass;
            var myMass          = massVolume.Mass;
            var mySemiMajorAxis = 5.055;
            var myEccentricity  = 0.8;
            var myInclination   = 0;
            var myLoAN          = 0;
            var myAoP           = -10;
            //var EccentricAnomaly = Math.Atan2()
            //var meanAnomaly =;
            double myLoP       = 0;
            double myMeanLongd = 355.5;
            //OrbitDB orbit = OrbitDB.FromAsteroidFormat(parent, parentMass, myMass, mySemiMajorAxis, myEccentricity, myInclination, myLoAN, myAoP, meanAnomaly, starSys.Game.CurrentDateTime);
            OrbitDB orbit = OrbitDB.FromMajorPlanetFormat(parent, parentMass, myMass, mySemiMajorAxis, myEccentricity, myInclination, myLoAN, myLoP, myMeanLongd, StaticRefLib.CurrentDateTime);

            var planetDBs = new List <BaseDataBlob>
            {
                position,
                massVolume,
                planetInfo,
                name,
                orbit,
                AsteroidDmg,
                sensorPfil
            };

            Entity newELE = new Entity(starSys, planetDBs);

            return(newELE);
        }
Example #19
0
        /// <summary>
        /// Creates our own solar system.
        /// This probibly needs to be Json! (since we're getting atmo stuff)
        /// Adds sol to game.StarSystems.
        /// </summary>
        public StarSystem CreateSol(Game game)
        {
            // WIP Function. Not complete.
            StarSystem sol = new StarSystem(game, "Sol", -1);

            Entity sun = _starFactory.CreateStar(sol, GameConstants.Units.SolarMassInKG, GameConstants.Units.SolarRadiusInAu, 4.6E9, "G", 5778, 1, SpectralType.G, "Sol");

            MassVolumeDB sunMVDB = sun.GetDataBlob <MassVolumeDB>();

            SystemBodyInfoDB mercuryBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true
            };
            MassVolumeDB mercuryMVDB         = MassVolumeDB.NewFromMassAndRadius(3.3022E23, Distance.KmToAU(2439.7));
            NameDB       mercuryNameDB       = new NameDB("Mercury");
            double       mercurySemiMajAxis  = 0.387098;
            double       mercuryEccentricity = 0.205630;
            double       mercuryInclination  = 0;
            double       mercuryLoAN         = 48.33167;
            double       mercuryLoP          = 77.45645;
            double       mercuryMeanLongd    = 252.25084;
            OrbitDB      mercuryOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.Mass, mercuryMVDB.Mass, mercurySemiMajAxis, mercuryEccentricity, mercuryInclination, mercuryLoAN, mercuryLoP, mercuryMeanLongd, GalaxyGen.Settings.J2000);
            PositionDB   mercuryPositionDB   = new PositionDB(OrbitProcessor.GetPosition(mercuryOrbitDB, game.CurrentDateTime), sol.Guid);
            Entity       mercury             = new Entity(sol.SystemManager, new List <BaseDataBlob> {
                mercuryPositionDB, mercuryBodyDB, mercuryMVDB, mercuryNameDB, mercuryOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, mercury);

            SystemBodyInfoDB venusBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true
            };
            MassVolumeDB venusMVDB         = MassVolumeDB.NewFromMassAndRadius(4.8676E24, Distance.KmToAU(6051.8));
            NameDB       venusNameDB       = new NameDB("Venus");
            double       venusSemiMajAxis  = 0.72333199;
            double       venusEccentricity = 0.00677323;
            double       venusInclination  = 0;
            double       venusLoAN         = 76.68069;
            double       venusLoP          = 131.53298;
            double       venusMeanLongd    = 181.97973;
            OrbitDB      venusOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.Mass, venusMVDB.Mass, venusSemiMajAxis, venusEccentricity, venusInclination, venusLoAN, venusLoP, venusMeanLongd, GalaxyGen.Settings.J2000);
            PositionDB   venusPositionDB   = new PositionDB(OrbitProcessor.GetPosition(venusOrbitDB, game.CurrentDateTime), sol.Guid);
            Entity       venus             = new Entity(sol.SystemManager, new List <BaseDataBlob> {
                venusPositionDB, venusBodyDB, venusMVDB, venusNameDB, venusOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, venus);

            SystemBodyInfoDB earthBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true
            };
            MassVolumeDB earthMVDB         = MassVolumeDB.NewFromMassAndRadius(5.9726E24, Distance.KmToAU(6378.1));
            NameDB       earthNameDB       = new NameDB("Earth");
            double       earthSemiMajAxis  = 1.00000011;
            double       earthEccentricity = 0.01671022;
            double       earthInclination  = 0;
            double       earthLoAN         = -11.26064;
            double       earthLoP          = 102.94719;
            double       earthMeanLongd    = 100.46435;
            OrbitDB      earthOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.Mass, earthMVDB.Mass, earthSemiMajAxis, earthEccentricity, earthInclination, earthLoAN, earthLoP, earthMeanLongd, GalaxyGen.Settings.J2000);

            earthBodyDB.Tectonics = TectonicActivity.EarthLike;
            PositionDB earthPositionDB = new PositionDB(OrbitProcessor.GetPosition(earthOrbitDB, game.CurrentDateTime), sol.Guid);
            Dictionary <AtmosphericGasSD, float> atmoGasses = new Dictionary <AtmosphericGasSD, float>();

            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(6), 0.78f);
            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(9), 0.12f);
            atmoGasses.Add(game.StaticData.AtmosphericGases.SelectAt(11), 0.01f);
            AtmosphereDB earthAtmosphereDB = new AtmosphereDB(1f, true, 71, 1f, 1f, 0.3f, 57.2f, atmoGasses); //TODO what's our greenhouse factor an pressure?

            Entity earth = new Entity(sol.SystemManager, new List <BaseDataBlob> {
                earthPositionDB, earthBodyDB, earthMVDB, earthNameDB, earthOrbitDB, earthAtmosphereDB
            });

            _systemBodyFactory.HomeworldMineralGeneration(game.StaticData, sol, earth);

            SystemBodyInfoDB lunaBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Moon, SupportsPopulations = true
            };
            MassVolumeDB lunaMVDB         = MassVolumeDB.NewFromMassAndRadius(0.073E24, Distance.KmToAU(1738.14));
            NameDB       lunaNameDB       = new NameDB("Luna");
            double       lunaSemiMajAxis  = Distance.KmToAU(0.3844E6);
            double       lunaEccentricity = 0.0549;
            double       lunaInclination  = 5.1;
            // Next three values are unimportant. Luna's LoAN and AoP regress/progress by one revolution every 18.6/8.85 years respectively.
            // Our orbit code it not advanced enough to deal with LoAN/AoP regression/progression.
            double     lunaLoAN        = 125.08;
            double     lunaAoP         = 318.0634;
            double     lunaMeanAnomaly = 115.3654;
            OrbitDB    lunaOrbitDB     = OrbitDB.FromAsteroidFormat(earth, earthMVDB.Mass, lunaMVDB.Mass, lunaSemiMajAxis, lunaEccentricity, lunaInclination, lunaLoAN, lunaAoP, lunaMeanAnomaly, GalaxyGen.Settings.J2000);
            PositionDB lunaPositionDB  = new PositionDB(OrbitProcessor.GetPosition(lunaOrbitDB, game.CurrentDateTime), sol.Guid);
            Entity     luna            = new Entity(sol.SystemManager, new List <BaseDataBlob> {
                lunaPositionDB, lunaBodyDB, lunaMVDB, lunaNameDB, lunaOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, luna);

            SystemBodyInfoDB marsBodyDB = new SystemBodyInfoDB {
                BodyType = BodyType.Terrestrial, SupportsPopulations = true
            };
            MassVolumeDB marsMVDB         = MassVolumeDB.NewFromMassAndRadius(0.64174E24, Distance.KmToAU(3396.2));
            NameDB       marsNameDB       = new NameDB("Mars");
            double       marsSemiMajAxis  = Distance.KmToAU(227.92E6);
            double       marsEccentricity = 0.0934; //wiki says .0934
            double       marsInclination  = 1.85;
            double       marsLoAN         = 49.57854;
            double       marsAoP          = 336.04084;
            double       marsMeanLong     = 355.45332;
            OrbitDB      marsOrbitDB      = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.Mass, marsMVDB.Mass, marsSemiMajAxis, marsEccentricity, marsInclination, marsLoAN, marsAoP, marsMeanLong, GalaxyGen.Settings.J2000);
            PositionDB   marsPositionDB   = new PositionDB(OrbitProcessor.GetPosition(marsOrbitDB, game.CurrentDateTime), sol.Guid);
            Entity       mars             = new Entity(sol.SystemManager, new List <BaseDataBlob> {
                marsPositionDB, marsBodyDB, marsMVDB, marsNameDB, marsOrbitDB
            });

            _systemBodyFactory.MineralGeneration(game.StaticData, sol, mars);

            /*
             *
             * SystemBody Mars = new SystemBody(sun, SystemBody.PlanetType.Terrestrial);
             * Mars.Name = "Mars";
             * Mars.Orbit = Orbit.FromMajorPlanetFormat(0.64174E24, sun.Orbit.Mass, 1.52366231, 0.09341233, 1.85061, 49.57854, 336.04084, 355.45332, GalaxyGen.J2000);
             * Mars.Radius = Distance.ToAU(3396.2);
             * Mars.BaseTemperature = (float)CalculateBaseTemperatureOfBody(sun, Mars.Orbit.SemiMajorAxis);// 210.1f + (float)Constants.Units.KELVIN_TO_DEGREES_C;
             * Mars.Tectonics = SystemBody.TectonicActivity.Dead;
             * Mars.SurfaceGravity = 3.71f;
             * Mars.Atmosphere = new Atmosphere(Mars);
             * Mars.Atmosphere.Albedo = 0.250f;
             * Mars.Atmosphere.SurfaceTemperature = Mars.BaseTemperature;
             * AddGasToAtmoSafely(Mars.Atmosphere, AtmosphericGas.AtmosphericGases.SelectAt(12), 0.95f * 0.01f);  // C02% * Mars Atms
             * AddGasToAtmoSafely(Mars.Atmosphere, AtmosphericGas.AtmosphericGases.SelectAt(6), 0.027f * 0.01f);  // N% * Mars Atms
             * AddGasToAtmoSafely(Mars.Atmosphere, AtmosphericGas.AtmosphericGases.SelectAt(9), 0.007f * 0.01f);  // O% * Mars Atms
             * AddGasToAtmoSafely(Mars.Atmosphere, AtmosphericGas.AtmosphericGases.SelectAt(11), 0.016f * 0.01f);  // Ar% * Mars Atms
             * Mars.Atmosphere.UpdateState();
             * Mars.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Mars.Position.System = Sol;
             * Mars.Position.X = x;
             * Mars.Position.Y = y;
             * sun.Planets.Add(Mars);
             *
             * SystemBody Jupiter = new SystemBody(sun, SystemBody.PlanetType.GasGiant);
             * Jupiter.Name = "Jupiter";
             * Jupiter.Orbit = Orbit.FromMajorPlanetFormat(1898.3E24, sun.Orbit.Mass, 5.20336301, 0.04839266, 1.30530, 100.55615, 14.75385, 34.40438, GalaxyGen.J2000);
             * Jupiter.Radius = Distance.ToAU(71492);
             * Jupiter.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Jupiter.Position.System = Sol;
             * Jupiter.Position.X = x;
             * Jupiter.Position.Y = y;
             * sun.Planets.Add(Jupiter);
             *
             * SystemBody Saturn = new SystemBody(sun, SystemBody.PlanetType.GasGiant);
             * Saturn.Name = "Saturn";
             * Saturn.Orbit = Orbit.FromMajorPlanetFormat(568.36E24, sun.Orbit.Mass, 9.53707032, 0.05415060, 2.48446, 113.71504, 92.43194, 49.94432, GalaxyGen.J2000);
             * Saturn.Radius = Distance.ToAU(60268);
             * Saturn.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Saturn.Position.System = Sol;
             * Saturn.Position.X = x;
             * Saturn.Position.Y = y;
             * sun.Planets.Add(Saturn);
             *
             * SystemBody Uranus = new SystemBody(sun, SystemBody.PlanetType.IceGiant);
             * Uranus.Name = "Uranus";
             * Uranus.Orbit = Orbit.FromMajorPlanetFormat(86.816E24, sun.Orbit.Mass, 19.19126393, 0.04716771, 0.76986, 74.22988, 170.96424, 313.23218, GalaxyGen.J2000);
             * Uranus.Radius = Distance.ToAU(25559);
             * Uranus.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Uranus.Position.System = Sol;
             * Uranus.Position.X = x;
             * Uranus.Position.Y = y;
             * sun.Planets.Add(Uranus);
             *
             * SystemBody Neptune = new SystemBody(sun, SystemBody.PlanetType.IceGiant);
             * Neptune.Name = "Neptune";
             * Neptune.Orbit = Orbit.FromMajorPlanetFormat(102E24, sun.Orbit.Mass, Distance.ToAU(4495.1E6), 0.011, 1.8, 131.72169, 44.97135, 304.88003, GalaxyGen.J2000);
             * Neptune.Radius = Distance.ToAU(24764);
             * Neptune.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Neptune.Position.System = Sol;
             * Neptune.Position.X = x;
             * Neptune.Position.Y = y;
             * sun.Planets.Add(Neptune);
             *
             * SystemBody Pluto = new SystemBody(sun, SystemBody.PlanetType.DwarfPlanet);
             * Pluto.Name = "Pluto";
             * Pluto.Orbit = Orbit.FromMajorPlanetFormat(0.0131E24, sun.Orbit.Mass, Distance.ToAU(5906.38E6), 0.24880766, 17.14175, 110.30347, 224.06676, 238.92881, GalaxyGen.J2000);
             * Pluto.Radius = Distance.ToAU(1195);
             * Pluto.Orbit.GetPosition(GameState.Instance.CurrentDate, out x, out y);
             * Pluto.Position.System = Sol;
             * Pluto.Position.X = x;
             * Pluto.Position.Y = y;
             * sun.Planets.Add(Pluto);
             *
             * GenerateJumpPoints(Sol);
             *
             * // Clean up cached RNG:
             * m_RNG = null;
             * GameState.Instance.StarSystems.Add(Sol);
             * GameState.Instance.StarSystemCurrentIndex++;
             */

            JPSurveyFactory.GenerateJPSurveyPoints(sol);

            game.GameMasterFaction.GetDataBlob <FactionInfoDB>().KnownSystems.Add(sol.Guid);
            return(sol);
        }
Example #20
0
 SystemBodyInfoDB(SystemBodyInfoDB origionalDB, SensorInfoDB sensorInfo)
 {
     UpdateDatablob(origionalDB, sensorInfo);
 }
Example #21
0
        /// <summary>
        /// This will work for missiles, ships, asteroids, and populations at some point.
        /// Damage type may eventually be required.
        /// </summary>
        /// <param name="damageableEntity"></param>
        /// <param name="damageAmount"></param>
        public static void OnTakingDamage(Entity damageableEntity, int damageAmount, DateTime atDateTime)
        {
            if (damageableEntity.HasDataBlob <AsteroidDamageDB>())
            {
                AsteroidDamageDB AstDmgDB = damageableEntity.GetDataBlob <AsteroidDamageDB>();
                AstDmgDB.Health = AstDmgDB.Health - damageAmount;

                if (AstDmgDB.Health <= 0)
                {
                    SpawnSubAsteroids(damageableEntity, atDateTime);
                }
            }
            else if (damageableEntity.HasDataBlob <ShipInfoDB>())
            {
                //do shield damage
                //do armor damage
                //for components:
                Game       game         = damageableEntity.Manager.Game;
                PositionDB ShipPosition = damageableEntity.GetDataBlob <PositionDB>();

                StarSystem mySystem;
                if (!game.Systems.TryGetValue(ShipPosition.SystemGuid, out mySystem))
                {
                    throw new GuidNotFoundException(ShipPosition.SystemGuid);
                }

                ComponentInstancesDB ShipInst = damageableEntity.GetDataBlob <ComponentInstancesDB>(); //These are ship components in this context

                int damageAttempt = 0;
                while (damageAmount > 0)
                {
                    int randValue = mySystem.RNG.Next((int)(damageableEntity.GetDataBlob <MassVolumeDB>().VolumeM3)); //volume in m^3

                    foreach (KeyValuePair <Entity, double> pair in ShipInst.ComponentDictionary)
                    {
                        if (pair.Value > randValue)
                        {
                            //check if this component is destroyed
                            //if it isn't get density
                            MassVolumeDB mvDB = pair.Key.GetDataBlob <MassVolumeDB>();

                            double DensityThreshold = 1.0; //what should this be?
                            double dmgPercent       = DensityThreshold * mvDB.Density * 1000;

                            int dmgDone = (int)(damageAmount * dmgPercent);

                            ComponentInfoDB         ciDB  = pair.Key.GetDataBlob <ComponentInfoDB>();
                            ComponentInstanceInfoDB ciiDB = pair.Key.GetDataBlob <ComponentInstanceInfoDB>();

                            if (ciiDB.HTKRemaining > 0)            //component is not destroyed yet
                            {
                                if (dmgDone >= ciiDB.HTKRemaining) //component is definitely wrecked
                                {
                                    damageAmount       = damageAmount - ciiDB.HTKRemaining;
                                    ciiDB.HTKRemaining = 0;
                                }
                                else
                                {
                                    ciiDB.HTKRemaining = ciiDB.HTKRemaining - damageAmount;
                                    damageAmount       = 0;
                                }
                            }
                            else
                            {
                                damageAttempt++;
                                if (damageAttempt == 20) // Aurora default, seems like an ok number to use for now.
                                {
                                    break;
                                }
                                /// <summary>
                                /// Need to pick a new component to try and destroy.
                                /// Should any damage get absorbed by the wreck?
                                /// How many of these failures should I run into before declaring the ship destroyed?
                                /// Should ship distruction happen differently?
                                /// </summary>
                                continue;
                            }


                            //compare this density to some density value to calculate how much to modify damage by
                            //if damage is greater than the HTK then the component is destroyed. modify damageAmount and move onto the next component.
                            //leave this loop if damage is zero.

                            break;
                        }
                    }
                    if (damageAttempt == 20) // need to copy this to fully break out of the loop;
                    {
                        break;
                    }
                }

                if (damageAttempt == 20) // the ship is destroyed. how to mark it as such?
                {
                    SpawnWreck(damageableEntity);
                }
                else
                {
                    ReCalcProcessor.ReCalcAbilities(damageableEntity);
                }
            }
            else if (damageableEntity.HasDataBlob <ColonyInfoDB>())
            {
                //Think about how to unify this one and shipInfoDB if possible.
                //do Terraforming/Infra/Pop damage
                Game game = damageableEntity.Manager.Game;

                ColonyInfoDB     ColIDB    = damageableEntity.GetDataBlob <ColonyInfoDB>();
                SystemBodyInfoDB SysInfoDB = ColIDB.PlanetEntity.GetDataBlob <SystemBodyInfoDB>();

                PositionDB ColonyPosition = ColIDB.PlanetEntity.GetDataBlob <PositionDB>();

                StarSystem mySystem; //I need all of this to get to the rng.
                if (!game.Systems.TryGetValue(ColonyPosition.SystemGuid, out mySystem))
                {
                    throw new GuidNotFoundException(ColonyPosition.SystemGuid);
                }

                //How should damage work here?
                //quarter million dead per strength of nuclear attack? 1 radiation/1 dust per strength?
                //Same chance to destroy components as ship destruction?

                //I need damage type for these. Missiles/bombs(missile damage but no engine basically) will be the only thing that causes this damage.
                //ColIDB.Population
                //SysInfoDB.AtmosphericDust
                //SysInfoDB.RadiationLevel


                //Installation Damage section:
                ComponentInstancesDB ColInst = damageableEntity.GetDataBlob <ComponentInstancesDB>(); //These are installations in this context
                int damageAttempt            = 0;
                while (damageAmount > 0)
                {
                    int randValue = mySystem.RNG.Next((int)damageableEntity.GetDataBlob <MassVolumeDB>().Volume);

                    foreach (KeyValuePair <Entity, double> pair in ColInst.ComponentDictionary)
                    {
                        if (pair.Value > randValue) //This installation was targeted
                        {
                            //check if this Installation is destroyed
                            //if it isn't get density
                            MassVolumeDB mvDB = pair.Key.GetDataBlob <MassVolumeDB>();

                            double DensityThreshold = 1.0; //what should this be?
                            double dmgPercent       = DensityThreshold * mvDB.Density;

                            int dmgDone = (int)(damageAmount * dmgPercent);

                            ComponentInfoDB         ciDB  = pair.Key.GetDataBlob <ComponentInfoDB>();
                            ComponentInstanceInfoDB ciiDB = pair.Key.GetDataBlob <ComponentInstanceInfoDB>();

                            if (ciiDB.HTKRemaining > 0)            //Installation is not destroyed yet
                            {
                                if (dmgDone >= ciiDB.HTKRemaining) //Installation is definitely wrecked
                                {
                                    damageAmount       = damageAmount - ciiDB.HTKRemaining;
                                    ciiDB.HTKRemaining = 0;
                                }
                                else
                                {
                                    ciiDB.HTKRemaining = ciiDB.HTKRemaining - damageAmount;
                                    damageAmount       = 0;
                                }
                            }
                            else
                            {
                                damageAttempt++;
                                if (damageAttempt == 20) // The planet won't blow up because of this, but no more attempts to damage installations should be made here.
                                {
                                    break;
                                }

                                continue;
                            }
                        }
                    }
                    if (damageAttempt == 20) // need to copy this to fully break out of the loop;
                    {
                        break;
                    }
                }

                //This will need to be updated to deal with colonies.
                ReCalcProcessor.ReCalcAbilities(damageableEntity);
            }
        }