public asteroidTypes getAsteroidType(asteroidTypes lastType, asteroidCircleTypes circleType)
        {
            int rand = RandomHelper.GetRandomInt(0, 100);

            switch (circleType)
            {
            case asteroidCircleTypes.VerySparse:
                if (rand < 45)
                {
                    return(asteroidTypes.None);
                }
                if (rand < 95)
                {
                    return(asteroidTypes.Sparse);
                }
                if (rand < 100)
                {
                    return(asteroidTypes.Dense);
                }
                break;

            case asteroidCircleTypes.Sparse:
                if (rand < 25)
                {
                    return(asteroidTypes.None);
                }
                if (rand < 85)
                {
                    return(asteroidTypes.Sparse);
                }
                return(asteroidTypes.Dense);

            case asteroidCircleTypes.Dense:
                if (rand < 5)
                {
                    return(asteroidTypes.None);
                }
                if (rand < 45)
                {
                    return(asteroidTypes.Sparse);
                }
                return(asteroidTypes.Dense);

            case asteroidCircleTypes.VeryDense:
                if (rand < 1)
                {
                    return(asteroidTypes.None);
                }
                if (rand < 30)
                {
                    return(asteroidTypes.Sparse);
                }
                return(asteroidTypes.Dense);
            }

            return(asteroidTypes.Sparse);
        }
        public asteroidTypes getAsteroidTypeStart(asteroidCircleTypes circleType)
        {
            //start should be

            int maxValue = 30; // ((int)asteroidCircleTypes.VeryDense) * 10;

            //very dense :  5 = none, 30 = sparse, 65 = dense
            //dense :  10 = none, 35 = sparse, 55 = dense
            //sparse : 20 = none, 65 = sparse, 15 = dense
            //very sparse : 54 none , 60 sparse,    5 dense
            //+ additional factor to repeat the previous tile

            switch (circleType)
            {
            case asteroidCircleTypes.VerySparse:
                break;
            }
            return((asteroidTypes)1);
        }
        private void createAsteroidCircle(int _circleNo, asteroidCircleTypes _type)
        {
            int           degrees  = 0;
            double        angle    = Math.PI * degrees / 180.0;
            int           x_last   = 0;
            int           y_last   = 0;
            asteroidTypes lastType = 0;

            while (degrees < 360)
            {
                angle = Math.PI * degrees / 180.0;
                int x_new = (int)(centerX + (_circleNo + 2) * Math.Cos(angle));
                int y_new = (int)(centerX + (_circleNo + 2) * Math.Sin(angle));
                if (x_new != x_last || y_new != y_last)
                {
                    x_last = x_new;
                    y_last = y_new;

                    lastType = typeDetector.getAsteroidType(lastType, _type);
                    if (lastType != asteroidTypes.None)
                    {
                        if (!systemElements.Any(e => e.x == x_new && e.y == y_new))
                        {
                            systemElement asteroid = createElement(_circleNo, 0);
                            asteroid.x    = x_new;
                            asteroid.y    = y_new;
                            asteroid.type = typeDetector.asteroidObjectId(lastType);
                            if (x_last == centerX || y_last == centerX)
                            {
                                writeCoords(asteroid);
                            }
                        }
                    }
                }
                degrees += 3;
            }
        }
        //obsolete
        //first version /did try to calculate system type during creation)
        private void createCircles()
        {
            int startingPropability = 20;
            int preventNewAsteroid  = 1;

            for (int i = 1; i < maxCircles; i++)
            {
                //there are fewer planets near the sun - prevent planet 2 + 4
                if (i == 2)
                {
                    continue;
                }

                var Type = typeDetector.getPlanetType(i);

                if (this.StartSystem)
                {
                    if (i > 11)
                    {
                        continue;
                    }

                    switch (Type)
                    {
                    case 9:
                    case 10:
                    case 11:
                    case 12:
                        createAsteroidCircle(i, (asteroidCircleTypes)(Type - 9));
                        AsteroidCirclesCount++;
                        break;

                    default:
                        createPlanetCircle(i, Type);
                        break;
                    }
                }
                else
                {
                    if (i == 4)
                    {
                        continue;
                    }

                    if (randomGenerator.Next(0, 100) < 5)
                    {
                        continue;                                                                                                             //skip circle in 5%
                    }
                    int asteroidCirclePropability = startingPropability + (i * 3) - (preventNewAsteroid * 100) - (AsteroidCirclesCount * 30); //asteroid circle - three innerost circles are not permitted (init-Value of preventNewAsteroid does this
                    if (randomGenerator.Next(0, 100) < asteroidCirclePropability)
                    {
                        AsteroidCirclesCount++;

                        asteroidCircleTypes asteroidCircleType = (asteroidCircleTypes)randomGenerator.Next(0, 4);
                        preventNewAsteroid = 3; // 1 + (int)asteroidCircleType;
                        createAsteroidCircle(i, asteroidCircleType);


                        if (showText && TextBox != null)
                        {
                            TextBox.Text += " Circle " + i + " Asteroid " + asteroidCircleType.ToString() + Environment.NewLine;
                        }
                    }
                    else
                    {
                        if (showText && TextBox != null)
                        {
                            TextBox.Text += " Circle " + i + " Planet" + Environment.NewLine;
                        }
                        createPlanetCircle(i, Type);
                        preventNewAsteroid = preventNewAsteroid > 0 ? preventNewAsteroid - 1 : 0;
                    }
                }
            }
        }
        private void createCircles(SolarSystem solarSystem)
        {
            int preventNewAsteroid = 0;

            for (int i = 1; i < maxCircles; i++)
            {
                var Type = typeDetector.getPlanetType(i);

                if (Type == 0)
                {
                    continue;
                }

                if (solarSystem.StartSystem)
                {
                    if (i > 11)
                    {
                        continue;
                    }

                    switch (Type)
                    {
                    case 9:
                    case 10:
                    case 11:
                    case 12:
                        createAsteroidCircle(solarSystem, i, (asteroidCircleTypes)(Type - 9));
                        AsteroidCirclesCount++;
                        solarSystem.AsteroidCirclesCount++;
                        break;

                    default:
                        createPlanetCircle(solarSystem, i, Type);
                        break;
                    }
                }
                else
                {
                    if (Type > 8 && Type < 13)
                    {
                        //do not place an asteroid circle right beneath another one
                        if (i == preventNewAsteroid + 1)
                        {
                            continue;
                        }

                        preventNewAsteroid = i;
                        AsteroidCirclesCount++;
                        solarSystem.AsteroidCirclesCount++;


                        asteroidCircleTypes asteroidCircleType = (asteroidCircleTypes)randomGenerator.Next(0, 4);

                        createAsteroidCircle(solarSystem, i, asteroidCircleType);


                        if (showText && TextBox != null)
                        {
                            TextBox.Text += " Circle " + i + " Asteroid " + asteroidCircleType.ToString() + Environment.NewLine;
                        }
                    }
                    else
                    {
                        if (showText && TextBox != null)
                        {
                            TextBox.Text += " Circle " + i + " Planet" + Environment.NewLine;
                        }
                        createPlanetCircle(solarSystem, i, Type);

                        preventNewAsteroid = preventNewAsteroid > 0 ? preventNewAsteroid - 1 : 0;
                    }
                }
            }
        }