Question

So I have been making this game with Action Script 3, and CS5.5. What you are trying to do is avoid asteroids while you fly through space. I thought it would be cool to have the planets in out solar system be moving down the screen throughout the game in the background. Kinda to make it look like you were flying pass them. The way I did this was I added five to their y coordinate each frame per second. Once their y coordinate reached 600 ( the bottom of the screen ) I would add a new planet which would do the same thing. For some reason once I got to Saturn everything got weird. Saturn came to early, and so did Uranus. I had no idea what was going on. I have been frustrated with this for a good hour. Here is the part where I think there is the problem.

public function onTick(timerEvent:TimerEvent):void
{

        earth.PlanetMovement(5);

        if (earth.y==600)
        {
            mars.PlanetsStart(300, -100);
            addChild( mars );
            levels=levels+5;
        }
        mars.PlanetMovement(5);
        if (mars.y==600)
        {
            jupiter.PlanetsStart(300,-150);
            addChild (jupiter);
            levels=levels+10;
        }
        jupiter.PlanetMovement(5);

        if (jupiter.y==600)
        {
            saturn.PlanetsStart(300,-155);
            addChild (saturn);
            levels=levels+20;
        }
        saturn.PlanetMovement(5);
        if (saturn.y==600)
        {
            uranus.PlanetsStart(300,-160)
            addChild ( uranus);
            levels=levels+25;
        }
        uranus.PlanetMovement(5);

PlanetMovement, and PlanetsStart are two functions in the Planets class. If you need more info please tell me.

EDIT: I guess I should explain further. PlanetsStart is a function that has the starting coordinate of each movieclip. So once earth reached a y coordinate of 600, then mars starts at (300, -100). Then it is added to the screen. levels is a variable that raises the score each fps. PlanetMovement is how much each movieclip will move each fps. If I were to use >= then the score would raise too much.

This is exactly what happens. earth shows up where it is supposed to. Then mars showd up on time. Then for some reason Saturn pops up in the middle of mars, and Jupiter. After this Saturn reaches the bottom making Uranus appear. Then Jupiter reaches the bottom, and everything works as it should. Saturn shows up, and then Uranus in order

Answer 1

Ugh. Unfortunately, this is more complex than you are implying. It would really help you to write a code plan of some sort first, develop some psuedo-code that will show basic logic (and the logic errors), and then code after that.

Below is an example of a better way to structure this idea. However, I don’t think your idea is terrible memory conscious. You should only bring in the planets as needed, and remove them as needed as well. Look into a technique called “object pooling” to help better structure this.

Solar system class:

package  
{
    import flash.display.MovieClip;
    import flash.events.Event;
    import flash.geom.Point;

    public class SolarSystem extends MovieClip 
    {
        private var PLANET_NAMES:Array = new Array("earth", "mars", "jupiter", "saturn", "uranus");

        // you will have to fix these values:
        private var PLANET_STARTS:Array = new Array(new Point(300, -100), new Point(300, -100),new Point(300, -100),new Point(300, -100),new Point(300, -100));

        private var planets:Array;
        private var maxY:Number = 600;
        private var speed:Number = 5;

        private var levels:Number = 0;
        private var levelIncrement:Number = 5;

        public function SolarSystem() 
        {
            super();
            addEventListener(Event.ADDED_TO_STAGE, initHnd, false, 0, true);
        }

        private function initHnd(e:Event):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, initHnd);

            runPlanets();

            addEventListener(Event.ENTER_FRAME, frameHnd, false, 0, true);
        }

        private function runPlanets():void 
        {
            for (var i:int = 0; i < PLANET_NAMES.length; i++) 
            {
                planets[i] = new Planet();
                planets[i].name = PLANET_NAMES[i];
                Planet(planets[i]).startPlanet(PLANET_STARTS[i]);
                this.addChild(planets[i]);
            }
        }

        private function frameHnd(e:Event):void 
        {
            if(planets && planets.length > 0){
                // move all the planets until they are too low, then remove them.
                // decrementing loop because planets will be being removed occasionally.
                for (var i:int = planets.length -1; i >= 0; i--) 
                {
                    if (planets[i] && Planet(planets[i]).y >= maxY) {

                        // this seems very strange to me, but it will replicate what your code says:
                        levels += (levels + levelIncrement);

                        try {
                            removeChild(Planet(planets[i]));
                            planets[i] = null;
                        }catch (e:Error) { }
                    } else if ( Planet(planets[i]).isMoving ){
                        Planet(planets[i]).movePlanet(0, speed);
                    }
                }
            } else {
                removeEventListener(Event.ENTER_FRAME, frameHnd);
            }
        }
    }
}

and here is the planet class:

package
{
    import flash.display.MovieClip;

    public class Planet extends MovieClip
    {
        private var _isMoving:Boolean = false;

        public function Planet()
        {
            super();
        }

        public function startPlanet(sx:Number, sy:Object):void
        {
            this.x = sx;
            this.y = sy;

            isMoving = true;
        }

        public function movePlanet(dx:Number, dy:Number):void
        {
            if (isMoving)
            {
                this.x += dx;
                this.y += dy;
            }
        }

        public function get isMoving():Boolean
        {
            return _isMoving;
        }

        public function set isMoving(value:Boolean):void
        {
            _isMoving = value;
        }
    }
}

Again, this is not the best way to do this, but it is more manageable to group concepts and actions into classes.

HTH.