# Need help with particlesystem

**URL:** <https://forum.kirupa.com/t/need-help-with-particlesystem/294829>\
**Category:** flash\
**Created:** [August 20, 2009, 3:35pm UTC](https://forum.kirupa.com/t/need-help-with-particlesystem/294829 "2009-08-20T15:35:44Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![Ryoka87](https://avatars.discourse-cdn.com/v4/letter/r/edb3f5/32.png) [@Ryoka87](https://forum.kirupa.com/u/Ryoka87)\
**Post date:** [August 20, 2009, 3:35pm UTC](https://forum.kirupa.com/t/need-help-with-particlesystem/294829/1 "2009-08-20T15:35:44Z")

</div>

Hey guys,

im trying to create a particlesystem where each particle moves by himself depending on which behavior has been assigned to him.

But… its slower than my grandma at the moment so I could really use some advice on how to make this structure a lot more faster!  
One thing I would like to keep though is the ability to change the behavior of the particle later on.

Just have 2 classes (Particle & FlyAroundStage) at the moment and one that creates the swf.

```auto
package
{
    import controlpanel.FPSCounter;
    
    import flash.display.Sprite;
    import flash.events.MouseEvent;
    
    import particles.Particle;
    import particles.behaviors.*;

    [SWF(width="800",height="600",frameRate="60",backgroundColor="#e9e9e9")]
    public class ParticleExpiriments extends Sprite
    {

        private var _particles:Array=new Array();
        
        private var _fpsCounter:FPSCounter;

        public function ParticleExpiriments()

        {
            addChild(_fpsCounter = new FPSCounter());
            for (var i:int=0; i < 100; i++)
            {

                var x:int=Math.random() * stage.stageWidth;
                var y:int=Math.random() * stage.stageHeight;
                var color:uint=Math.random() * 0xFFFFFF;

                var particle:Particle=new Particle(x, y, 5, color);
                particle.behavior = new FlyAroundStage(particle);
                
                _particles.push(particle);
                stage.addChild(particle);

            }

        }

    }
}

```

```auto
package particles
{
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.EventDispatcher;

    import particles.behaviors.FlyAroundStage;

    public class Particle extends Sprite
    {
        //particle appearance
        private var _particle:Sprite;
        private var _size:int;
        private var _color:uint;
        private var _filterArray:Array;
        private var _behavior:FlyAroundStage;

        public function Particle(x:int=0, y:int=0, size:int=5, color:uint=0x000000, cacheAsBitmap:Boolean=true)
        {
            this.x=x;
            this.y=y;
            _size=size;
            _color=color;
            this.cacheAsBitmap=cacheAsBitmap;

            this.addEventListener(Event.ADDED_TO_STAGE, init, false, 0, true);
        }

        private function init(evt:Event):void
        {
            this.removeEventListener(Event.ADDED_TO_STAGE, init);
            drawParticle();
            addChild(_particle);
        }

        //draws the particle
        private function drawParticle():void
        {
            _particle=new Sprite();
            _particle.graphics.beginFill(_color, 1);
            _particle.graphics.drawCircle(0, 0, _size);
            _particle.graphics.endFill();
        }

        //Getters & Setters

        public function set behavior(behavior:FlyAroundStage):void
        {
            _behavior=behavior;
        }

    }
}

```

```auto
package particles.behaviors
{
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.utils.*;

    import particles.Particle;

    public class FlyAroundStage extends EventDispatcher
    {

        private var _particle:Particle;
        private var _xVel:int;
        private var _yVel:int;
        private var _stageBorder:int;
        private var _direction:int;
        private var _speed:int;
        private var _lastTime:int;

        public function FlyAroundStage(particle:Particle, speed:int=5, direction:int=45)
        {
            _particle=particle;
            _speed=speed;
            _direction=direction;

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

        private function onEnter(evt:Event):void
        {
            var time:int=(getTimer() - _lastTime);
            _lastTime=getTimer();

            _xVel=Math.cos(deg2Rad(_direction)) * _speed;
            _yVel=Math.sin(deg2Rad(_direction)) * _speed;

            _particle.x+=(_xVel * time) / 100;
            _particle.y+=(_yVel * time) / 100;

            trace(time)
            trace(_xVel);

        }

        //converts degrees to radians
        private function deg2Rad(degrees:Number):Number
        {
            return degrees * (Math.PI / 180);
        }

        //converts radians to degrees
        private function rad2Deg(radians:Number):Number
        {
            return radians * (180 / Math.PI);
        }

        //Getters & Setters

        public function get speed():int
        {
            return _speed;
        }

        public function set speed(speed:int):void
        {
            _speed=speed;
        }

        public function get direction():int
        {
            return _direction;
        }

        public function set direction(direction:int):void
        {
            _direction=direction;
        }

    }
}

```

Its just flying down to the right. I want to make this way more sophisticated later on but first in need to get the structure right because right now, even though its just flying in a straight path, its way too slow.