El reto I: Crear un juego en 15 días. Generación de enemigos.

Como ya comente en anteriores post, he parado el proceso de creación del juego por que he llegado a un punto en el que no me es posible continuar sin un terminal con el que probar el juego. El teléfono lo tengo desde hace unos días, pero estoy a la espera de poder desbloquearlo para permitir el debug.

Como la cosa esta tardando bastante mas de lo que esperaba (por culpa mía, básicamente), voy a publicar un poco del código del juego, concretamente el que se encarga de generar a los enemigos.

Mi idea de esta serie de post no era publicar código, si no comentar el proceso, pero como he dicho, como estoy tardando tanto, y me lo pidieron en uno de los comentarios ahí va.

Este método se encarga de enviar oleadas de enemigos de manera mas o menos aleatoria. Os invito a que me comentéis mejoras o cualquier cosa sobre el código.

        //Variables enemigos//
        private int _numeroEnemigosEnRafaga;
        private int _enemigosActualesEnRafaga;
        //Determinal el número máximo y mínimo para las rafagas de enemigos.
        private const int MIN_ENEMIGOS = 1;
        private const int MAX_ENEMIGOS = 4;
        //Tiempo máximo y mínimo de espera entre enemigos.
        private const int MAX_TIEMPO_REFAGA = 4;
        private const int MIN_TIEMPO_REFAGA = 1;
        //determinal por que lado han aparecido los ultimos enemigos.
        private int _ultimoLado;
        //Tiempo entre enemigos dentro de la rafaga
        private  float _intervaloEntreEnemigos = 700f;
        private float _intervaloSiguienteRafaga;
        //Temporizador de tiempo entre enemigo dentro de la rafaga
        private float _temporizador;
        //Temporizador tiempo entre rafagas.
        private float _temporizadorRafagas;
        //estado de la rafaga.
        private bool _estaEnRafaga;
    
        private void SetEnemigos(GameTime gameTime)
        {
            _temporizador += gameTime.ElapsedGameTime.Milliseconds;

            //Si no esta en rafaga, se genera una nueva rafaga de enemigos.
            if(!_estaEnRafaga)
            {
                //intervalo de tiempo entre enemigos por defecto;
                _intervaloEntreEnemigos = 700f;
                _enemigosActualesEnRafaga = 0;
                //se recuperan cuantos enemigos van a aparecer en la rafaga.
                _numeroEnemigosEnRafaga = random.Next(MIN_ENEMIGOS, MAX_ENEMIGOS);
                //Se cambia el lado por el que apareceran los enemigos.
                _ultimoLado++;
                //Intervalo de tiempo para la siguiente rafaga
                _intervaloSiguienteRafaga = 1000f * random.Next(MIN_TIEMPO_REFAGA, MAX_TIEMPO_REFAGA);

                //Se añade algo de aleatoriedad al tiempo entre enemigos.
                int variadorTiempoEntreEnemigos = 100 * random.Next(MIN_TIEMPO_REFAGA, MAX_TIEMPO_REFAGA);
                int signoRandom = random.Next(1, 3);
                _intervaloEntreEnemigos = signoRandom == 1
                                              ? _intervaloEntreEnemigos + variadorTiempoEntreEnemigos
                                              : _intervaloEntreEnemigos - variadorTiempoEntreEnemigos;
            }

            if(_enemigosActualesEnRafaga < _numeroEnemigosEnRafaga)
            {
                _estaEnRafaga = true;
                //Si no ha pasado el tiempo suficiente entre enemigos no hacemos nada.
                if (_intervaloEntreEnemigos > _temporizador)
                {
                    return;
                }

                //Se lanza al enemigo por el lado correspondiente.
                if (_ultimoLado % 2 == 0)
                {
                    Enemy enemigo = enemies.Where(e => e.IsVisible == false).Skip(0).Take(11).FirstOrDefault();
                    if (enemigo != null) enemigo.IsVisible = true;
                }
                else
                {
                    Enemy enemigo = enemies.Where(e => e.IsVisible == false).Skip(11).Take(11).FirstOrDefault();
                    if (enemigo != null) enemigo.IsVisible = true;

                }
                _enemigosActualesEnRafaga++;
                _temporizador = 0f; 
            }
            else
            {
                //Se acaba la rafaga.
                //Comienza el contador para la siguiente rafaga de enemigos.
                _temporizadorRafagas += gameTime.ElapsedGameTime.Milliseconds;

                if (_intervaloSiguienteRafaga > _temporizadorRafagas)
                {
                    return;
                }
                _temporizadorRafagas = 0;
                _estaEnRafaga = false;
            }
        }

Y este método es llamado en cada update:

 /// <summary>
        /// Animates each enemy and allow them to kill the player.
        /// </summary>
        private void UpdateEnemies(GameTime gameTime)
        {

            SetEnemigos(gameTime);

            foreach (Enemy enemy in enemies)
            {
                enemy.Update(gameTime);

                // Touching an enemy instantly kills the player
                if (enemy.BoundingRectangle.Intersects(Player.BoundingRectangle))
                {
                    OnPlayerKilled(enemy);
                }

                // Falling off the bottom of the level kills the player.
                if (enemy.BoundingRectangle.Top >= Height * Tile.Height)
                {
                    enemy.OnKilled(enemy);
                }
            }
        }