[SOLUCIONADO] Mínimo nro de la nave sobreviviente?

[Tachikomaia]

Pseudocódigo:

Código a:

Parte 1:
Un objeto llamado jugador está presente.
Establezco la defensa (Df) del jugador.
Establezco el tamaño del jugador, en base a su Df.
Naves creadas (N) es 0.
 
Parte 2:
N++
Aparece nave enemiga nro N, en las coordenadas 0,0, es decir arriba a la izquierda.
Se establece su Df, con cierto azar.
Se establece su tamaño en base a su Df.
Se establece su posición X (es 0 por defecto, como dije, pero se puede cambiar, y es lo que hago aquí), con azar aunque en los límites del ancho de mi pantalla (800).
Se establece una velocidad para el jugador, 1+9/su Df.
Se analiza qué flechas están presionadas y en base a ello el jugador se mueve hacia arriba, abajo, etc, diagonal arriba-derecha, etc.
N2 = 1
Para cada nave nro N2 mientras N sea mayor o igual que N:
   Se mueve hacia abajo, a una velocidad de 1+9/su Df.
   Si termina tocando al jugador
      Si la Df del jugador > la Df de la nave
         La Df del jugador aumenta en una cantidad igual a la Df de la nave.
         Su tamaño aumenta correspondientemente.
         La nave desaparece.
      sino
         Game over.
      fin del si
   sino si su ubicación es mayor de 700 (sería "muy abajo", fuera de la pantalla)
      La nave desaparece.
   fin del si
fin del mientras
 
Parte 3:
Ir a parte 2.
 

Básicamente se maneja una nave que debe "comer" (colisionar) a las más pequeñas que ella y evitar a las más grandes o iguales. Constantemente aparecen naves, así que de a poco el juego se va haciendo más lento, debido a la gran cantidad de naves en pantalla. Por supuesto quiero evitar ese enlentecimiento. Acabo de notar que podría convertir todo lo de parte 2 en una función e incluirla en la parte 3, de ese modo sucedería más seguido el proceso. Pero estoy interesado en pulir cierta idea, o ver si se puede pulir.

Antes de empezar el mientras, N2 se establece como 1. Si pudiera, en vez de poner ese valor, poner el valor del nro de la nave más vieja, el mientras funcionaría desde donde debe. O sea, si la nave nro 1, nro 2, etc, hasta 40, ya no están, entonces es inconveniente que el do se aplique a la nave 1 y demás, que ya no están! En este caso N2 debería iniciar con 40.

¿Pero cómo puedo tener marcado el nro de la mínima nave sobreviviente?

Por ahora lo que tengo es que inicialmente es 1. O sea, la nave nro 1 está en pantalla. Min=1. Lo defino en la parte 1 del código.
Cuando una nave desaparece, si su nro es Min entonces Min aumenta 1.
El problema es que uno puede destruir por ejemplo la 2 antes que la 1 y entonces según lo que he puesto, Min aumentaría a 2 cuando se destruya la 1, pero como la 2 ya está destruída entonces nunca aumentará a 3.

Puedo crear un "array" que marque qué naves fueron destruídas, pero quería saber si hay algo más sencillo que eso. Algo que requiera menos variables.

Gracias.

Si quieren les paso el código original y/o el juego, pero es un cuadrado y triángulos nomás, y es posible que graficamente no vaya a mejorarlo.

[jc_moj]

Hola

Este es un claro ejemplo que se soluciona muy fácilmente con programación orientada a objetos.

Personalmente he hecho más de un juego en el que no paran de aparecer y desaparecer enemigos y ,desde luego, recorrer todos los que se han creado desde el principio con un bucle, incluso los que se supone que ya ha desaparecido es una locura.

Lo que yo hago es ir creando nuevos enemigos y añadirlos a una lista, cuando un enemigo es destruido o sale de pantalla pues destruyo el objeto y lo saco de la lista, así, con un bucle que recorra la lista, siempre recorre los que actualmente hay, ni uno más.

Desde luego, de la forma que lo quieres hacer, no veo la manera.

Un saludo

[Tachikomaia]

Con tu método además evitas que se hagan cosas con naves que ya no están. Lo que yo estoy planteando en realidad no soluciona eso. Si la mínima nave existente es la 40 no se harán cosas con la 1, 2, etc, hasta ahí bien, pero puede que no exista la 41 y otras varias y se tratarían igual, por eso digo que en realidad mi método no soluciona eso. Esperaré un poco pero es probable que pruebe tu método o haga algo parecido. Lo que no me gusta es el tener que crear variables.

[Tachikomaia]

En teoría encontré una solución pero hay un error cuya causa no entiendo. El error es que, llegado un punto, a veces aparecen naves que desaparecen enseguida.

Código a:

actions for fotograma 1
      Player.Df = 100;
      setProperty (Player, _xscale, 100+Player.Df/100);
      setProperty (Player, _yscale, 100+Player.Df/100);
      N = 0;
   actions for fotograma 2
      // Aparece nave.
      N = N+1;
      Res = "Nave"+N;
      Resu = Res+".Df";
      attachMovie("Nave", Res, N);
      trace ("Nave"+N+" agregada");
      set (Resu, random(N)+1);
      EvaledResu = eval(Resu);
      setProperty (Res, _x, random(799)+1);
      setProperty (Res, _xscale, 100+EvaledResu/10);
      setProperty (Res, _yscale, 100+EvaledResu/10);
      // Movimiento del jugador.
      Player.Sp = 1+9/Player.Df;
      if (Key.isDown(Key.LEFT)) {
         if (Key.isDown(Key.UP)) {
            V = Math.sqrt(Player.Sp*Player.Sp/2);
            Player._x = Player._x-V;
            Player._y = Player._y-V;
         } else if (Key.isDown(Key.DOWN)) {
            V = Math.sqrt(Player.Sp*Player.Sp/2);
            Player._x = Player._x-V;
            Player._y = Player._y+V;
         } else {
            Player._x = Player._x-Player.Sp;
         }
      } else if (Key.isDown(Key.RIGHT)) {
         if (Key.isDown(Key.UP)) {
            V = Math.sqrt(Player.Sp*Player.Sp/2);
            Player._x = Player._x+V;
            Player._y = Player._y-V;
         } else if (Key.isDown(Key.DOWN)) {
            V = Math.sqrt(Player.Sp*Player.Sp/2);
            Player._x = Player._x+V;
            Player._y = Player._y+V;
         } else {
            Player._x = Player._x+Player.Sp;
         }
      } else if (Key.isDown(Key.UP)) {
         Player._y = Player._y-Player.Sp;
      } else if (Key.isDown(Key.DOWN)) {
         Player._y = Player._y+Player.Sp;
      }
      // Movimiento de las naves.
      N2 = 1;
      do {
         Res = "Nave"+N2;
         NaveDf = eval(Res+".Df");
         setProperty (Res, _y, getProperty(Res, _y)+1+9/eval(Res+".Df"));
         trace (Res+" se movió");
         if (Player.hitTest(eval(Res)) == true) {
            // Contacto.
            if (Player.Df>NaveDf) {
               Player.Df = Player.Df+NaveDf;
               setProperty (Player, _xscale, 100+Player.Df/100);
               setProperty (Player, _yscale, 100+Player.Df/100);
               removeMovieClip (Res);
               trace (Res+" removida");
               setProperty ("Nave"+N, _name, "Nave"+N2);
               trace ("Nave"+N+" transformada en Nave"+N2);
               if (N>1) {
                  N = N-1;
                  N2 = N2-1;
               }
            } else {
               stop ();
            }
         } else if (getProperty(Res, _y)>700) {
            // Fuera de la pantalla.
            removeMovieClip (Res);
            trace (Res+" removida");
            setProperty ("Nave"+N, _name, "Nave"+N2);
            trace ("Nave"+N+" transformada en Nave"+N2);
            if (N>1) {
               N = N-1;
               N2 = N2-1;
            }
         }
         N2 = N2+1;
      } while (N>=N2);
      stop ();
   actions for fotograma 3
      gotoAndPlay (2);
 

Lo que se me ocurrió fue dar a la última nave agregada el nombre de la removida. Básicamente es esto (está incluído en el code de arriba):

Código a:

removeMovieClip (Res);
            trace (Res+" removida");
            setProperty ("Nave"+N, _name, "Nave"+N2);
            trace ("Nave"+N+" transformada en Nave"+N2);
            if (N>1) {
               N = N-1;
               N2 = N2-1;
            }
 

Se remueve la nave que corresponda (lo citado es de un evento en que debe removerse, sea porque se salió de la pantalla o tocó la nave del jugador). Luego, la última que se agregó toma su nombre. Digamos que se removió Nave1 y la última es Nave72, lo que sucede con esto es que ahora la Nave72 pasa a llamarse Nave1. N marca el nro de naves en pantalla y N2 es el contador del while, marca qué nave se está analizando. El if sinceramente no entiendo bien si está bien o no, pero dudo que sea el problema, pues el único caso en que no se aplicaría es que la cantidad de naves en pantalla sea 1, cosa que rara vez puede ocurrir.
https://dl.dropboxusercontent.com/u/169164922/9.swf

No sé, voy a probar insertar las naves con números en ellas a ver si veo mejor qué pasa, si la que desaparece es sustituída (¿debería no reducir N2?) o qué.

N se reduce porque hay una nave menos.
N2 se reduce porque ahora hay una nueva naveN2, o sea que debe analizarse.

Quizá el problema ocurre cuando la nave eliminada es N...
Supongamos que N y N2 son 70.
Se elimina la nave N2.
La nave N toma el valor de N2.
¡Pero ya no existe!

No entiendo cómo ese error puede causar una aparición y luego una desaparición, pero en fin, seguiré investigando.

EDIT:
Ok, hice lo de ponerles números que se vieran en pantalla, y también separé el while en frames, para ver mejor paso por paso qué pasaba (lo intenté con trace pero no me había servido, posiblemente lo hice mal). Así medio por casualidad noté algo que podría explicar el error: El depth no cambia.

La nave N2 tiene un depth N. Al insertar una nave N con un depth N, hace que la nave N2 con depth N desaparezca, aunque no sea de nombre N.
Solución posible: No asignar N al depth, crear otra variable.

Pero esto también parece que sirve:
eval(Res+".swapDepths")("Nave"+N);

A decir verdad lo de la propiedad _name se me ocurrió también medio por casualidad, porque la había visto recientemente buscando otra cosa.