public static short Generate()
        {
            int dieRoll = DieRoll.Roll2D6();

            switch (dieRoll)
            {
            case 2: return(0);

            case 3: return(0);

            case 4: return(1);

            case 5: return(2);

            case 6: return(3);

            case 7: return((short)(4 + DieRoll.Roll1D6()));

            case 8: return((short)(5 + DieRoll.Roll1D6()));

            case 9: return((short)(6 + DieRoll.Roll1D6()));

            case 10: return((short)(7 + DieRoll.Roll1D6()));

            case 11: return((short)(8 + DieRoll.Roll1D6()));

            case 12: return(99);
            }

            throw new Exception("Unexpected die roll");
        }
Esempio n. 2
0
        private static bool IsSystemPresent(SubsectorDensity density)
        {
            int roll;

            switch (density)
            {
            case SubsectorDensity.Rift:
                roll = DieRoll.Roll2D6();

                if (roll == 12)
                {
                    return(true);
                }

                break;

            case SubsectorDensity.Sparse:
                roll = DieRoll.Roll1D6();

                if (roll == 6)
                {
                    return(true);
                }

                break;

            case SubsectorDensity.Scattered:
                roll = DieRoll.Roll1D6();

                if (roll >= 5)
                {
                    return(true);
                }

                break;

            case SubsectorDensity.Standard:
                roll = DieRoll.Roll1D6();

                if (roll >= 4)
                {
                    return(true);
                }

                break;

            case SubsectorDensity.Dense:
                roll = DieRoll.Roll1D6();

                if (roll >= 3)
                {
                    return(true);
                }

                break;
            }

            return(false);
        }
        public static double Generate()
        {
            int dieRoll = DieRoll.Roll2D6();

            switch (dieRoll)
            {
            case 2:
            case 3:
                return(-1.0 + DieRoll.Roll1D10());

            case 4:
            case 5:
                return(9.0 + DieRoll.Roll1D10());

            case 6:
            case 7:
                return(19.0 + DieRoll.Roll1D10());

            case 8:
            case 9:
                return(20.0 + DieRoll.Roll1D10());

            case 10:
            case 11:
                return(29.0 + DieRoll.Roll1D10());

            default:
                dieRoll = DieRoll.Roll1D6();

                switch (dieRoll)
                {
                case 1:
                case 2:
                    return(49 + DieRoll.Roll1D10());

                case 3:
                    return(59 + DieRoll.Roll1D10());

                case 4:
                    return(69 + DieRoll.Roll1D10());

                case 5:
                    return(79 + DieRoll.Roll1D10());

                default:
                    return(90.00);
                }
            }
        }
Esempio n. 4
0
        public static int Generate(string classification)
        {
            int dieRoll = DieRoll.Roll1D6();

            if (classification == StellarClassifications.A ||
                classification == StellarClassifications.B)
            {
                dieRoll++;
            }

            if (dieRoll < 5)
            {
                return(0);
            }

            dieRoll = DieRoll.Roll1D6();

            if (classification == StellarClassifications.A ||
                classification == StellarClassifications.B)
            {
                dieRoll++;
            }

            switch (dieRoll)
            {
            case 1:
                return(1);

            case 2:
                return(1);

            case 3:
                return(2);

            case 4:
                return(3);

            case 5:
                return(3);

            default:
                return(3);
            }
        }
Esempio n. 5
0
        public static string Generate(string orbitType)
        {
            int dieRoll = DieRoll.Roll1D6();

            if (orbitType.Equals(OrbitTypes.Outer))
            {
                dieRoll -= 2;
            }

            if (dieRoll < 2)
            {
                return(PlanetDensities.Low);
            }

            if (dieRoll > 4)
            {
                return(PlanetDensities.High);
            }

            return(PlanetDensities.Average);
        }
Esempio n. 6
0
        public static GasGiant Generate(Distance orbitalDistance, short orbitNumber, string occupiedType,
                                        string orbitType, IStar parentStar, double combinedLuminosity)
        {
            int size;

            var gasGiant = new GasGiant
            {
                OrbitalDistance = orbitalDistance,
                Density         = PlanetDensities.Low
            };

            if (DieRoll.Roll1D6() < 3)
            {
                //Small
                size = -1;
                gasGiant.Description = "Small";
            }
            else
            {
                //Large
                size = -2;
                gasGiant.Description = "Large";
            }

            gasGiant.Diameter          = PlanetDiameterGenerator.Generate(occupiedType, size);
            gasGiant.Mass              = PlanetMassGenerator.Generate(gasGiant.Diameter, gasGiant.Density);
            gasGiant.OrbitNumber       = orbitNumber;
            gasGiant.OrbitalDistance   = orbitalDistance;
            gasGiant.OrbitEccentricity = OrbitalEccentricityGenerator.Generate();

            gasGiant.OrbitalPeriod = OrbitalPeriodGenerator.Generate(parentStar, gasGiant);

            gasGiant.RotationPeriod  = RotationPeriodGenerator.Generate(parentStar.Mass, gasGiant.OrbitalDistance);
            gasGiant.AxialTilt       = AxialTiltGenerator.Generate();
            gasGiant.AxialTiltEffect = TiltEffectGenerator.Generate(gasGiant.AxialTilt);

            SatellitesGenerator.Generate(parentStar, gasGiant, combinedLuminosity);

            return(gasGiant);
        }
Esempio n. 7
0
        public static int Generate(string occupiedType, int size)
        {
            int numberOfSatellites = 0;

            if (occupiedType.Equals(OccupiedTypes.GasGiant))
            {
                if (size == -1)
                {
                    //Small
                    numberOfSatellites = DieRoll.Roll2D6() - 4;
                }
                else if (size == -2)
                {
                    //Large
                    numberOfSatellites = DieRoll.Roll2D6();
                }
            }
            else if (size == 0)
            {
                numberOfSatellites = 0;
            }
            else if (occupiedType.Equals(OccupiedTypes.CapturedPlanet))
            {
                numberOfSatellites = 0;
            }
            else
            {
                numberOfSatellites = DieRoll.Roll1D6() - 3;
            }

            if (numberOfSatellites < 1)
            {
                numberOfSatellites = 0;
            }

            return(numberOfSatellites);
        }
Esempio n. 8
0
        public static short Generate(int worldSize)
        {
            int dieRoll;

            if (worldSize == -1)                 /* Small Gas Giant */
            {
                dieRoll = DieRoll.Roll2D6() - 6; //Max 6
            }
            else if (worldSize == -2)            /* Large Gas Giant */
            {
                dieRoll = DieRoll.Roll2D6() - 4; //Max 8
            }
            else
            {
                dieRoll = DieRoll.Roll1D6() - 3;  //Max 3
            }

            if (dieRoll == 0)
            {
                //Ring
                return(0);
            }

            if (dieRoll >= worldSize &&
                worldSize >= 0)
            {
                dieRoll = worldSize - 1;
            }

            if (dieRoll < 1)
            {
                dieRoll = 0;
            }

            return((short)dieRoll);
        }
        public static string Generate(string stellarClassification, string primaryLuminosity = null)
        {
            /* Check for rare values */
            int dieRoll;

            if (primaryLuminosity == null)
            {
                dieRoll = DieRoll.Roll3D6();

                if (dieRoll == 3)
                {
                    return(StellarLuminosities.Ia);
                }
                if (dieRoll == 4)
                {
                    return(StellarLuminosities.Ib);
                }
            }

            dieRoll = DieRoll.Roll2D6() + GetModifier(primaryLuminosity);

            switch (dieRoll)
            {
            case 2:
                return(StellarLuminosities.II);

            case 3:
                return(StellarLuminosities.III);

            case 4:
                if (stellarClassification == StellarClassifications.M)
                {
                    return(StellarLuminosities.V);
                }
                else
                {
                    return(StellarLuminosities.IV);
                }

            case 5:
                return(StellarLuminosities.V);

            case 6:
                return(StellarLuminosities.V);

            case 7:
                return(StellarLuminosities.V);

            case 8:
                return(StellarLuminosities.V);

            case 9:
                return(StellarLuminosities.V);

            case 10:
                return(StellarLuminosities.V);

            case 11:
                return(StellarLuminosities.V);

            case 12:
                return(StellarLuminosities.V);

            case 13:
                return(StellarLuminosities.V);

            default:
                if (DieRoll.Roll1D6() < 4)
                {
                    return(StellarLuminosities.V);
                }
                else
                {
                    return(StellarLuminosities.D);
                }
            }

            throw new Exception("Unsupported Type");
        }