package  
{
  import org.flixel.FlxPoint;
  import org.flixel.FlxSprite;
  import org.flixel.FlxState;
  import org.flixel.FlxGroup;
  import org.flixel.FlxTileblock;
  import org.flixel.FlxG;
  import org.flixel.FlxU;
  import com.gskinner.utils.Rnd;
   
  public class PlayState extends FlxState
  {
    [Embed(source = 'back.png')] private var ImgBack:Class;
    [Embed(source = 'mist.png')] private var ImgMist:Class;
    private var sky:FlxSprite; // our background sky
    private var ground:FlxSprite; // our ground object
    public static var wind:Number = 0.0; // direction and force of the wind
    private var mist:FlxSprite;
    private var treegrp:FlxGroup; // all of our tree pixels...
    public static var leafgrp:FlxGroup; // all of our leaves in a group
    private var timer:Number = 0;
    private var goal:Number = 0;
    private var mistDir:int = -1;
    private var wispBackGrp:FlxGroup;
    private var wispFrontGrp:FlxGroup;
    private var ghostgrp:FlxGroup;
   
    public function PlayState()
    {
      // the background graphic
      sky = add(new FlxSprite(0, 0, null).loadGraphic(ImgBack, false, false, FlxG.width, FlxG.height, true)) as FlxSprite;
      // our different layers
      wispBackGrp = add(new FlxGroup()) as FlxGroup;
      ghostgrp = add(new FlxGroup()) as FlxGroup;
      treegrp = add(new FlxGroup()) as FlxGroup;
      leafgrp = add(new FlxGroup()) as FlxGroup;
      wispFrontGrp = add(new FlxGroup()) as FlxGroup;
      // build the tree!
      BuildTree();
      BuildLeaves();
      // this is the mist graphic that goes on top of everything else.
      mist = add(new FlxSprite( -250 + (FlxG.width / 2), FlxG.height-45, null).loadGraphic(ImgMist, false, false, 500, FlxG.height, true)) as FlxSprite;
      mist.moves = true;
      mist.solid = false;
      mist.alpha = 0.44;
      // the ground sprite
      ground = add(new FlxSprite( -50, FlxG.height - 5, null).createGraphic(FlxG.width + 50, 20, 0xff000000, true, "ground")) as FlxSprite;
      ground.fixed = true;  // set it to fixed, not moves, and solid for collision.
      ground.moves = false;
      ground.solid = true;
     
      //lets seed the ground with some leaves already:
      var tL:LeafBit;
      for (var tY:int = FlxG.height -6; tY > FlxG.height - 8; tY--)
      {
        for (var tX:int = -50; tX <= FlxG.width+50; tX++)
        {
          if (Rnd.boolean(0.5))
          {
            tL = leafgrp.add(new LeafBit(tX, tY, Rnd.integer(1, 2)) as LeafBit) as LeafBit;
            tL.solid = true;
            tL.falling = true;
            tL.landed = false;
          }
        }
      }
     
      // set the wind's speed and goal
      wind = Rnd.float( -10, 10);
      goal = Rnd.float( -10, 10);
    }
   
    private function BuildTree():void
    {
      //build our tree - this gets a bit complicated...
      // start at the bottom
      for (var tY:int = FlxG.height - 6; tY > FlxG.height - 25; tY--)
      {
       
        for (var tX:int = (FlxG.width/2) - 2; tX <= (FlxG.width/2) + 2; tX++)
        {
          treegrp.add(new TreeBit(tX, tY,50) as TreeBit);
        }
      }
     
      // bottom block of branches
      for (tY = FlxG.height -20; tY > FlxG.height - 25; tY--)
      {
        for (tX = (FlxG.width / 2) -10; tX <= (FlxG.width / 2) + 10; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.2, 0.4)))
          {
            treegrp.add(new TreeBit(tX, tY, Rnd.integer(4,6)) as TreeBit);
          }
        }
      }
     
      //make the central mass of branches
      for (tY = FlxG.height - 25; tY > FlxG.height - 36; tY--)
      {
        for (tX = (FlxG.width / 2) - 6; tX <= (FlxG.width / 2) + 6; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.5, 0.7)))
          {
            treegrp.add(new TreeBit(tX, tY, Rnd.integer(6,8)) as TreeBit);
          }
        }
      }
     
      //make the left-side mass of branches
      for (tY = FlxG.height - 23; tY > FlxG.height - 36; tY--)
      {
        for (tX = (FlxG.width / 2) - 18; tX <= (FlxG.width / 2) - 6; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.1, 0.4)))
          {
            treegrp.add(new TreeBit(tX, tY, Rnd.integer(4,6)) as TreeBit);
          }
        }
      }
     
      //make the right-side mass of branches
      for (tY = FlxG.height - 23; tY > FlxG.height - 36; tY--)
      {
        for (tX = (FlxG.width / 2) + 6; tX <= (FlxG.width / 2) + 18; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.1, 0.4)))
          {
            treegrp.add(new TreeBit(tX, tY, Rnd.integer(4,6)) as TreeBit);
          }
        }
      }
     
      //make the upper middle mass of branches
      for (tY = FlxG.height - 36; tY > FlxG.height - 47; tY--)
      {
        for (tX = (FlxG.width / 2) - 14; tX <= (FlxG.width / 2) + 14; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.2, 0.6)))
          {
            treegrp.add(new TreeBit(tX, tY, Rnd.integer(3,5)) as TreeBit);
          }
        }
      }
     
      // make the top branches
      for (tY = FlxG.height - 47; tY > FlxG.height - 52; tY--)
      {
        for (tX = (FlxG.width / 2) - 8; tX <= (FlxG.width / 2) + 8; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.1, 0.3)))
          {
            treegrp.add(new TreeBit(tX, tY, Rnd.integer(2,4)) as TreeBit);
          }
        }
      }
    }
   
    private function BuildLeaves():void
    {
      // bottom block of branches
      for (var tY:int = FlxG.height -18; tY > FlxG.height - 25; tY--)
      {
        for (var tX:int = (FlxG.width / 2) - 12; tX <= (FlxG.width / 2) + 12; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.3, 0.5)))
          {
            leafgrp.add(new LeafBit(tX, tY, Rnd.integer(1,2)) as LeafBit);
          }
        }
      }
     
      //make the central mass of branches
      for (tY = FlxG.height - 25; tY > FlxG.height - 36; tY--)
      {
        for (tX = (FlxG.width / 2) - 6; tX <= (FlxG.width / 2) + 6; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.6, 0.8)))
          {
            leafgrp.add(new LeafBit(tX, tY, Rnd.integer(1,2)) as LeafBit);
          }
        }
      }
     
      //make the left-side mass of branches
      for (tY = FlxG.height - 21; tY > FlxG.height - 38; tY--)
      {
        for (tX = (FlxG.width / 2) - 20; tX <= (FlxG.width / 2) - 6; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.2, 0.5)))
          {
            leafgrp.add(new LeafBit(tX, tY, Rnd.integer(1,2)) as LeafBit);
          }
        }
      }
     
      //make the right-side mass of branches
      for (tY = FlxG.height - 21; tY > FlxG.height - 38; tY--)
      {
        for (tX = (FlxG.width / 2) + 6; tX <= (FlxG.width / 2) + 20; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.2, 0.5)))
          {
            leafgrp.add(new LeafBit(tX, tY, Rnd.integer(1,2)) as LeafBit);
          }
        }
      }
     
      //make the upper middle mass of branches
      for (tY = FlxG.height - 36; tY > FlxG.height - 47; tY--)
      {
        for (tX = (FlxG.width / 2) - 16; tX <= (FlxG.width / 2) + 16; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.3, 0.7)))
          {
            leafgrp.add(new LeafBit(tX, tY, Rnd.integer(1,2)) as LeafBit);
          }
        }
      }
     
      // make the top branches
      for (tY = FlxG.height - 47; tY > FlxG.height - 54; tY--)
      {
        for (tX = (FlxG.width / 2) - 10; tX <= (FlxG.width / 2) + 10; tX++)
        {
          if (Rnd.boolean(Rnd.float(0.2, 0.4)))
          {
            leafgrp.add(new LeafBit(tX, tY, Rnd.integer(1,2)) as LeafBit);
          }
        }
      }
    }
   
    override public function update():void
    {
      if (timer <= 0)
      {
        // move the wind's strength
        wind += Rnd.float(0.1, 0.3) * (goal/Math.abs(goal));
        timer = 0.2;
        // push each branch
        var t:TreeBit;
        for each (t in treegrp.members)
          t.push(wind);
        //push each leaf
        var l:LeafBit;
        for each (l in leafgrp.members)
          l.push(wind);
      }
      else
        timer -= FlxG.elapsed;
       
      // here's some logic to get the mist moving and to stay in the bounds.
      if (Math.abs(wind) >= Math.abs(goal))
        goal = Rnd.float( -10, 10);
      mist.velocity.x = wind;
      if (mist.x < -500 + FlxG.width) mist.x = -500 + FlxG.width;
      else if (mist.x > 0) mist.x = 0;
     
      // collide leaves with other leaves and the ground
      leafgrp.collide(leafgrp);
      ground.collide(leafgrp);
     
      //randomly add new leaves from off the screen...
      if (Rnd.boolean(0.01))
        SpawnLeaf();
      // random wisps
      if (Rnd.boolean(0.01))
        SpawnBackWisp();
      if (Rnd.boolean(0.005))
        SpawnFrontWisp();
      // random ghosts
      if (Rnd.boolean(0.001))
        SpawnGhost();
     
      super.update();
    }
   
    private function SpawnBackWisp():void
    {
      // spawn a random wisp off the screen.
      var tW:WispBit;
      tW = wispBackGrp.getFirstAvail() as WispBit;
      if (tW == null)
      {
        if (wind < 0)
          tW = wispBackGrp.add(new WispBit(FlxG.width + 1, Rnd.integer( -1, FlxG.height - 4))) as WispBit;
        else if (wind > 0)
          tW = wispBackGrp.add(new WispBit(-1, Rnd.integer( -1, FlxG.height - 4))) as WispBit;
      }
      else
        tW.reset(FlxG.width + 1, Rnd.integer( -1, FlxG.height - 4));
    }
    private function SpawnFrontWisp():void
    {
      // spawn a random wisp off the screen in the foreground.
      var tW:WispBit;
      tW = wispFrontGrp.getFirstAvail() as WispBit;
      if (tW == null)
      {
        if (wind < 0)
          tW = wispFrontGrp.add(new WispBit(FlxG.width + 1, Rnd.integer( -1, FlxG.height - 4))) as WispBit;
        else if (wind > 0)
          tW = wispFrontGrp.add(new WispBit(-1, Rnd.integer( -1, FlxG.height - 4))) as WispBit;
      }
      else
        tW.reset(FlxG.width + 1, Rnd.integer( -1, FlxG.height - 4));
     
    }
   
    private function SpawnGhost():void
    {
      // spawn a random ghost
      var g:Ghost;
      g = ghostgrp.getFirstAvail() as Ghost;
      if (g == null)
        ghostgrp.add(new Ghost(Rnd.integer(2, FlxG.width - 7), Rnd.integer(FlxG.height + 2, FlxG.height - 4))) as Ghost;
      else
        g.reset(Rnd.integer(2, FlxG.width - 7), Rnd.integer(FlxG.height + 2, FlxG.height - 4));
    }
   
    private function SpawnLeaf():void
    {
      // spawn a random leaf off the screen.
      var tL:LeafBit;
      tL = leafgrp.getFirstAvail() as LeafBit;
      var pos:FlxPoint = new FlxPoint(0,0);
      if (wind > 0)
      {
        pos.x = -1;
        pos.y = Rnd.integer( -FlxG.width, FlxG.width - 6);
      }
      else if (wind < 0)
      {
        pos.x = FlxG.width + 1;
        pos.y = Rnd.integer( -FlxG.width, FlxG.width - 6);
      }
      else
      {
        if (Rnd.boolean())
        {
          pos.x = -1;
          pos.y = Rnd.integer( -FlxG.width, FlxG.width - 6);
        }
        else
        {
          pos.x = FlxG.width + 1;
          pos.y = Rnd.integer( -FlxG.width, FlxG.width - 6);
        }
      }
      if (tL != null)
        tL.reset(pos.x,pos.y);
      else
        tL = leafgrp.add(new LeafBit(pos.x, pos.y, Rnd.integer(1, 2))) as LeafBit;
      tL.solid = true;
      tL.falling = true;
      tL.landed = false;
    }
  }

}

package  
{
  import org.flixel.FlxPoint;
  import org.flixel.FlxSprite;
  import org.flixel.FlxObject;
  import org.flixel.FlxG;
  import com.gskinner.utils.Rnd;
 
  public class TreeBit extends FlxSprite
  {
    public var weight:Number = 0; // this is how much this part of the tree 'weighs'. The heavier it is, the more wind force it takes before it should move...
    private var init:FlxPoint;
    public function TreeBit(X:Number, Y:Number, w:int):void
    {
      super(X, Y, null);
      createGraphic(1, 1,0xff000000, false, null);
      width = 1;
      height = 1;
      weight = w;
      reset(X, Y);
    }
   
    public function push(Force:Number):void
    {
      // take the amount of force being applied, subtact the weight of this bit (+/- a random amount), the remainder is how much it moves.
      var m:Number = Math.abs(Force) - weight;
      var dir:int = Force / Math.abs(Force);
      // theres a change the branch will move, and if it doesn't it goes back to where it started
      if (Rnd.boolean(Rnd.float(0.1, 0.3)) && m > 0)
        x = init.x +(dir * Math.ceil(m/2));
      else
        snapback();
    }
   
    override public function reset(X:Number, Y:Number):void
    {
      super.reset(X, Y);
      init = new FlxPoint(X, Y);
      fixed = false;
      moves = true;
      solid  = true;
      alpha = 1;
    }
   
    public function snapback():void
    {
      x = init.x;
      y = init.y;
    }
   
    override public function update():void
    {
      super.update();
    }
  }

}

package
{
  import org.flixel.FlxPoint;
  import org.flixel.FlxSprite;
  import org.flixel.FlxObject;
  import org.flixel.FlxG;
  import com.gskinner.utils.Rnd;
 
  public class LeafBit extends FlxSprite
  {
    public var weight:Number = 0; // affects how much the wind moves this leaf
    private var init:FlxPoint; // the 'starting' point of the leaf to snap back to
    private var colors:Array; // array of colors
    public var falling:Boolean = false; // if the leaf is falling or not
    public var landed:Boolean = false; // if the leaf is on the ground or not
   
    public function LeafBit(X:int, Y:int, w:int)
    {
      super(X, Y, null);
     
      colors = new Array();
      // this is an array of possibly 'fall' colors for our leaves.
      colors.push(0xffb14211);
      colors.push(0xffd9541a);
      colors.push(0xff663408);
      colors.push(0xffbc5815);
      colors.push(0xffecb338);
      colors.push(0xffbf1313);
     
      createGraphic(1, 1, colors[Rnd.integer(0, 5)], false, null);
      width = 1;
      height = 1;
      weight = w;
      reset(X, Y);
    }
   
    public function push(Force:Number):void
    {
      // take the amount of force being applied, subtact the weight of this bit (+/- a random amount), the remainder is how much it moves.
      var m:Number = Math.ceil((Math.abs(Force) - weight) / 2);
      var dir:int = Force / Math.abs(Force);
      if (landed)
      {
        //if we landed, then we can only move if the wind is strong, and if we're not under another leaf
        if (m > 2)
        {
          if (Rnd.boolean(0.3))
          {
            var tP:FlxSprite = new FlxSprite(x, y - 1);
            tP.createGraphic(1, 1, 0x00000000);
            if (!tP.collide(PlayState.leafgrp))
            {
              velocity.y = -((dir * m) * Rnd.float( -0.15, 0.15));
              falling = true;
              landed = false;
            }
          }
        }
      }
      else if (!falling)
      {
        //if we're not falling, the wind might push us a little bit (or not) if it pushes too hard, we might start falling.
        if (Rnd.boolean(Rnd.float(0.1, 0.3)) && m > 0)
        {
          if (m > 2)
            if (Rnd.boolean(0.01))
            {
              falling = true;
              acceleration.y = weight;
              solid = true;
            }
            else
              x = init.x + (dir * 2);
          else
            x = init.x + (dir * m);
        }
        else
          snapback();
      }
      else
      {
        // if we're falling, the velocity can randomly change, but it's based on the wind.
        velocity.x = ((dir * m) * Rnd.float(0.85, 1.15)) + Rnd.integer( -2, 2);;
        velocity.y += ((m * 0.5) * Rnd.float(-0.15, 0.15)) * Rnd.sign(0.3);
      }
     
    }
   
    override public function reset(X:Number, Y:Number):void
    {
      super.reset(X, Y);
      init = new FlxPoint(X, Y);
      fixed = false;
      moves = true;
      solid  = false;
      alpha = 1;
    }
   
    public function snapback():void
    {
      // put the leaf back where it started
      x = init.x;
      y = init.y;
    }
   
    override public function update():void
    {
      // if the leaf falls too far off the screen, we'll kill it
      if (y > FlxG.height) kill();
      super.update();
    }
   
    override public function hitBottom(Contact:FlxObject, Velocity:Number):void
    {
      // we only want to land on top of the ground or other leaves that have landed.
      var hit:Boolean = false;
      if (Contact is LeafBit)
      {
        var f:LeafBit = Contact as LeafBit;
        if (!f.landed) hit = true;
      }
      else hit = true;
      if (hit)
      {
        super.hitBottom(Contact, 0);
        // when we do land on something, we stop our movement and set falling to false
        velocity.x = 0;
        falling = false;
        landed = true;
      }
    }
   
  }

}

package
{
  import org.flixel.FlxPoint;
  import org.flixel.FlxSprite;
  import org.flixel.FlxObject;
  import org.flixel.FlxG;
  import com.gskinner.utils.Rnd;
 
  public class WispBit extends FlxSprite
  {
   
    private var lastdir:Number = 0; // this is to rememer which way we were blowing. If the wind changes too much, we'll die.
    private var fading:Boolean = false;
   
    public function WispBit(X:int, Y:int):void
    {
      super(X, Y, null);
      createGraphic(1, 1, 0xffffffff);
      width = 1;
      height = 1;
      reset(X, Y);
    }
   
    override public function reset(X:Number, Y:Number):void
    {
      super.reset(X, Y);
      alpha = Rnd.float(0.1, 0.6);
      lastdir = PlayState.wind;
      fading = false;
    }
   
    override public function update():void
    {
      if (dead || !exists) return;
      if (fading)
      {
        // if we're fading out, decrease our opacity each tick and then kill us for real when it's 0.
        if (alpha <= 0)
        {
          dead = true;
          exists = false;
        }
        else
          alpha -= 0.2;
      }
      else if (Math.abs(PlayState.wind) < 3) kill(); // if the wind stops or slows down too much, we just die right away.
      else if (lastdir < 0) // if we were going one way and then the wind suddenly reversed on us, we die.
      {
        if (x < 0) kill();
        if (PlayState.wind >= 0) kill();
      }
      else if (lastdir > 0)
      {
        if (x > FlxG.width) kill();
        if (PlayState.wind <= 0) kill();
      }
      // our speed and direction is randomly based on the wind.
      velocity.x = (PlayState.wind * 20) * Rnd.float(0.75, 1.25);
      velocity.y += (PlayState.wind * 0.05) * Rnd.float(-0.25, 0.25);
      lastdir = PlayState.wind;
      super.update();
    }
   
    override public function kill():void
    {
      // if we get killed, we really just want to fade out.
      fading = true;
    }
  }

}

package
{
  import org.flixel.FlxPoint;
  import org.flixel.FlxSprite;
  import org.flixel.FlxObject;
  import org.flixel.FlxG;
  import org.flixel.FlxGroup;
  import com.gskinner.utils.Rnd;
 
  public class Ghost extends FlxGroup
  {
   
    private var ghostParts:Array; // this array will hold all of our ghost's parts
    private var fading:Boolean = false; // track if we're fading in or not
    private var timer:Number = 0;
   
    public function Ghost(X:Number, Y:Number):void
    {
      super();
      x = X;
      y = Y;
      ghostParts = new Array();
      // our ghost is made up of smaller FlxSprites so that we have more control over alpha.
      ghostParts.push(add(new FlxSprite(0, 0).createGraphic(5, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(0, 1).createGraphic(1, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(2, 1).createGraphic(1, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(4, 1).createGraphic(1, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(0, 2).createGraphic(5, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(0, 3).createGraphic(2, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(3, 3).createGraphic(2, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(0, 4).createGraphic(2, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(3, 4).createGraphic(2, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(0, 5).createGraphic(5, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(0, 6).createGraphic(5, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(0, 7).createGraphic(1, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(2, 7).createGraphic(1, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(4, 7).createGraphic(1, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(0, 8).createGraphic(1, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(2, 8).createGraphic(1, 1, 0xffffffff)));
      ghostParts.push(add(new FlxSprite(4, 8).createGraphic(1, 1, 0xffffffff)));
      reset(X, Y);
    }
   
    override public function reset(X:Number, Y:Number):void
    {
      super.reset(X, Y);
      x = X;
      y = Y;
      var gP:FlxSprite;
      // set each ghost part to be almost invisible.
      for each (gP in ghostParts)
        gP.alpha = 0.1;
      fading = false;
      timer = 0;
      velocity.y -= Rnd.float(16,24); // set random starting y velocity
    }
   
    override public function update():void
    {
      //basically, we go through each ghost part, starting with the top, and if we're fading in make it more opaque until it's full,
      // each piece after the first's alpha is based on the level right above it so we get a gradual effect of most opaque->least opaque
      // when ghost is faded in all the way, turn on 'fading' and then we reverse the process.
      if (dead || !exists) return;
      if (timer <= 0)
      {
        var gP:FlxSprite;
        var i:int;
        if (fading)
        {
          if (ghostParts[0].alpha <= 0) kill();
          else
          {
            for (i = 0; i < ghostParts.length; i++)
            {
              switch(i)
              {
                case 0:
                  ghostParts[i].alpha -= 0.15;
                  break;
                case 1:
                case 2:
                case 3:
                  ghostParts[i].alpha = ghostParts[0].alpha -0.1;
                  break;
                case 4:
                  ghostParts[i].alpha = ghostParts[2].alpha -0.1;
                  break;
                case 5:
                case 6:
                  ghostParts[i].alpha = ghostParts[4].alpha -0.1;
                  break;
                case 7:
                case 8:
                  ghostParts[i].alpha = ghostParts[5].alpha -0.1;
                  break;
                case 9:
                  ghostParts[i].alpha = ghostParts[7].alpha -0.1;
                  break;
                case 10:
                  ghostParts[i].alpha = ghostParts[9].alpha -0.1;
                  break;
                case 11:
                case 12:
                case 13:
                  ghostParts[i].alpha = ghostParts[10].alpha -0.1;
                  break;
                case 14:
                case 15:
                case 16:
                  ghostParts[i].alpha = ghostParts[11].alpha -0.1;
                  break;
              }
            }
          }
        }
        else
        {
          if (ghostParts[0].alpha >= 1) fading = true;
          else
          {
            for (i = 0; i < ghostParts.length; i++)
            {
              switch(i)
              {
                case 0:
                  ghostParts[i].alpha += 0.15;
                  break;
                case 1:
                case 2:
                case 3:
                  ghostParts[i].alpha = ghostParts[0].alpha -0.1;
                  break;
                case 4:
                  ghostParts[i].alpha = ghostParts[2].alpha -0.1;
                  break;
                case 5:
                case 6:
                  ghostParts[i].alpha = ghostParts[4].alpha -0.1;
                  break;
                case 7:
                case 8:
                  ghostParts[i].alpha = ghostParts[5].alpha -0.1;
                  break;
                case 9:
                  ghostParts[i].alpha = ghostParts[7].alpha -0.1;
                  break;
                case 10:
                  ghostParts[i].alpha = ghostParts[9].alpha -0.1;
                  break;
                case 11:
                case 12:
                case 13:
                  ghostParts[i].alpha = ghostParts[10].alpha -0.1;
                  break;
                case 14:
                case 15:
                case 16:
                  ghostParts[i].alpha = ghostParts[11].alpha -0.1;
                  break;
              }
            }
          }        
        }
        velocity.x = Rnd.float(-2,2)/4; // we change x velocity randomly
        timer = FlxG.elapsed*3.5;
      }
      else
        timer -= FlxG.elapsed;
      super.update();
    }
   
  }

}

package  
{
  import org.flixel.FlxSprite;
  import org.flixel.FlxObject;
  import org.flixel.FlxG;
  import com.gskinner.utils.Rnd;
 
  public class Flake extends FlxSprite
  {
    public var _melting:Boolean = false; // this flag is set when the flake starts melting.
    public var _falling:Boolean = false; // this flag is set while the flake is falling
   
    private var _melt_timer:Number = 3; // we don't start melting for a few ticks after melting is set, after it starts to melt, this is a timer.
   
    public function Flake(X:Number, Y:Number):void
    {
      // create our flake - just a 1x1 white sprite.
      super(X, Y, null);
      createGraphic(1, 1, 0xffffffff, false, null);
      // we set our max velocities to make sure they don't go too fast
      maxVelocity.y = 8;
      maxVelocity.x = 8;
      // we set the width and offset to something a bit smaller than 1 pixel so that they don't get stuck to each other's corner as often.
      width = 0.6;
      offset.x = 0.2;
      // we call reset so that we can set our other properties.
      reset(X, Y);
    }
   
    override public function reset(X:Number, Y:Number):void
    {
      super.reset(X, Y);
      // we reset our flake's properties so it's ready to start falling
      _falling = true; // flakes won't collide with other falling flakes.
      fixed = false; // falling flakes aren't fixed. when they land, they become fixed
      moves = true; // and moves is set to false so other flakes that land on them won't push them around
      solid = true; // new flakes are solid
      _melting = false; // new flakes aren't melting
      alpha = 1; // and are 100% visible
      acceleration.x = 0; // new flakes aren't yet affected by the wind
      acceleration.y = 4; // but they are affected by gravity
    }
   
    /**
     * <code>melt</code> is called when we want this flake to start melting.
     */
    public function melt():void
    {
      if (!_melting)
      {
        _melting = true;
        _melt_timer = 2;
      }
    }
   
    /**
     * <code>refreeze</code> stops the flake from melting and makes it solid again (for collision).
     */
    public function refreeze():void
    {
      if (_melting)
      {
        _melting = false;
        solid = true;
      }
    }
   
    override public function update():void
    {
      // if the flake is currently melting, we wait until the melt timer is <= 0 and then we start fading out the flake.
      // when the flake is halfway faded out, we make it not solid so that it starts to fall away.
      // once it's alpha =0 , we kill it.
      if (_melting)
      {
        if (_melt_timer <= 0)
        {
          _melt_timer = 1;
          alpha -= 0.2;
        }
        else
          _melt_timer -= FlxG.elapsed;
        if (alpha < 0.5)
          solid = false;
        else if (alpha <= 0)
          kill();
      }
      if (_falling) acceleration.x = PlayState.wind *  Rnd.float(0.8, 1.2); // if the flake is falling, it's affected by the wind (with some randomness)
      if (y > FlxG.height) kill(); // if the flake ever ends up below the bottom of the screen, we'll kill it.
      super.update();
    }
   
    override public function hitBottom(Contact:FlxObject, Velocity:Number):void
    {
      // if this flake lands on something, we want to first check to see what it landed on.
      // if it lands on another flake, then we only want to collide if that flake is not also falling.
      // otherwise, we'll land on anything else there is (the ground).
      var hit:Boolean = false;
      if (Contact is Flake)
      {
        var f:Flake = Contact as Flake;
        if (!f._falling) hit = true;
      }
      else hit = true;
      if (hit)
      {
        super.hitBottom(Contact, 0);
        // when we do land on something, we stop our movement and set falling to false so other flakes can land on us.
        velocity.x = 0;
        _falling = false;
      }
    }
  }
}

package
{
  import org.flixel.FlxSprite;
  import org.flixel.FlxState;
  import org.flixel.FlxGroup;
  import org.flixel.FlxTileblock;
  import org.flixel.FlxG;
  import org.flixel.FlxU;
 
  import com.gskinner.utils.Rnd;
  public class PlayState extends FlxState
  {
    [Embed(source = 'tiles.png')]private var ImgTile:Class; // our ground tileblock's image which is a 50x1 image, mostly white with a few gray colors for variety
   
    public static var wind:Number = 0.0; // our current wind speed.
   
    private var sky:FlxSprite; // the blue sky sprite
    private var sun:FlxSprite; // the yellow sun sprite
    private var ground:FlxTileblock; // the ground
    private var flakeGrp:FlxGroup; // group for our flakes
    private var _wind_change:Number = 0; // a timer for changing our wind speed
    private var _night_timer:Number = 20; // timer for our night's duration
    private var dayMode:int = 0; // which 'mode' of day it it
    private var _throttle:Number = 1; // throttle to slow things down a little bit
   
    override public function create():void
    {
      sky = add(new FlxSprite(0, 0, null).createGraphic(FlxG.width, FlxG.height, 0xff75E8FF, true, "sky")) as FlxSprite; // create and add our sky
      sky.alpha = 0; // make it invisible for now
      sun = add(new FlxSprite(Rnd.integer( -4, FlxG.width - 6), FlxG.height, null).createGraphic(10, 10, 0xffFFFF00, true, "sun")) as FlxSprite; // create and add our sun. Put it below the horizon.
      wind = Rnd.integer( -50, 50)/10; // define our starting wind speed.
      _wind_change = Rnd.integer(0, 5); // randomly choose how long before our wind changes
      ground = add(new FlxTileblock( -50, FlxG.height - 5, FlxG.width + 50, 20)) as FlxTileblock; // create the ground
      ground.loadGraphic(ImgTile); // load ground images
      ground.fixed = true; // set it to fixed, not moves, and solid for collision.
      ground.moves = false;
      ground.solid = true;
      flakeGrp = add(new FlxGroup()) as FlxGroup; // create our flakeGroup and add a random number of flakes to start with
      for (var i:int = 0; i < Rnd.integer(100,200); i++)
        flakeGrp.add(new Flake(Rnd.integer( -50, FlxG.width + 50), Rnd.integer( -50, -5)));
      _throttle = 1; // initialize our throttle
    }
   
    override public function update():void
    {
      var f:Flake;
      var f2:Flake;
      flakeGrp.collide(flakeGrp); // collision for the flakes against each other, and the ground
      ground.collide(flakeGrp);
      if (_night_timer <= 0)
      {
        // this is our 'day time' logic.
        // find out which mode we're in
        switch(dayMode)
        {
          case 0:
            // day just started, brighten the sky until it's 1/2 bright and then start the sun rising, and set mode to 1.
            if (sky.alpha < 0.5)
              sky.alpha += 0.1;
            else
            {
              sun.x = Rnd.integer( -4, FlxG.width - 6);
              sun.velocity.y = -12;
              dayMode = 1;
            }
            break;
          case 1:
            // continue brightening the sky and check to see if the sun has reached it's apex - if it has, send it back down, set mode to 2
            if (sky.alpha < 1)
              sky.alpha += 0.1;
             if (sun.y <= -3)
             {
               sun.velocity.y = 12;
               dayMode = 2;
             }
             break;
          case 2:
            // check if the sun has gone down and stop it from moving if it has. start fading out the sky.
            if (sun.velocity.y != 0)
            {
              if (sun.y >= FlxG.height)
                sun.velocity.y = 0;
            }
            else
            {
              if (sky.alpha > 0)
                sky.alpha -= 0.1;
              else
              {
                // when the sky is dark, set the mode to 0 (for tomorrow)
                dayMode = 0;
                _night_timer = 20; // reset the night_timer
                _throttle = 1; // and the throttle
               
                // go through all the flakes that exist. If they are melting, refreeze them.
                for (var l:int = 0; l < flakeGrp.members.length; l++)
                {
                  f = flakeGrp.members[l];
                  if (f != null && !f.dead && f.exists && f._melting)
                    f.refreeze();
                }
               
              }
            }
            break;
        }
        var covered:Boolean = false; // this is for seeing if the flake should melt or not.
        if (sky.alpha == 1)
        {
          // if the sky is fully brightened, then we're going to start checking for melting flakes.
          if (_throttle <= 0)
          {
            _throttle = 1;
            // we don't want to do this too often, so we use the throttle.
            for (var j:int = 0; j < flakeGrp.members.length;j++)
            {
              f = flakeGrp.members[j] as Flake;
              // we're going to look at all the flakes in the group. If we see one that's not dead, and not already melting, then we'll check it.
              if (f!=null && !f.dead && f.exists && !f._melting)
              {
                // this is to add a bit of chaos to the code. There will be a chance that this eligible flake will not even be checked
                // the higher the sun is in the sky, the higher the chance is that it will be checked.
                if (Rnd.boolean(1 - (((sun.y-3)/(FlxG.height-5))*0.25)))
                {
                  covered = false;
                  // so now we know we are going to check this flake, we look at all the OTHER flakes in the group.
                  for (var k:int = 0; k < flakeGrp.members.length; k++)
                  {
                    if (k != j)
                    {
                      f2 = flakeGrp.members[k] as Flake;
                      // if we find a flake that's not dead, and is solid, etc, and it is directly above our current flake, then
                      // the current flake is 'covered' and saved from melting.
                      if (f2 != null && !f2.dead && f2.exists && f2.solid)
                        if ((int(f2.x) == int(f.x)  && int(f2.y) == int(f.y) - 1)) covered = true;
                      if (covered) break;
                    }
                  }
                  // if the current flake is not covered, then it melts
                  if (!covered) f.melt();
                }
              }
            }
          }
          else _throttle-= FlxG.elapsed;
        }
      }
      else
      {
        // this is the night logic. we use the night timer to see how long before the sun comes up
        _night_timer -= FlxG.elapsed;
        // if it's time to change the wind, we do some random stuff to either add or subtract from the amount of wind there is.
        // we check to make sure the wind speed isn't too high or low.
        if (_wind_change <= 0)
        {
          _wind_change = Rnd.integer(0, 5);
          var sign:int;
          if (wind == 10)
            sign = -1;
          else if (wind == -10)
            sign = 1;
          else
            sign = Rnd.sign(0.5);
          wind += ((Rnd.integer(5, 20)/10) * sign)
          if (wind > 10)
            wind = 10;
          else if (wind < -10)
            wind = -10;
        }
        else
          _wind_change-= FlxG.elapsed;
        // if the night is not almost over, we'll continue and spawn new flakes.
        if (_night_timer >= 4)
        {
          // using the throttle to keep from overloading things
          if (_throttle <= 0)
          {
            _throttle = 1;
            // we're going to create a random number of new flakes, with less flakes being created at the start of the night and near the end.
            // this is a pretty subtle effect
            for (var i:int = 0; i < (Rnd.integer(170, 230) - (4 * Math.abs(_night_timer - (24)))); i++)
            {
              f = flakeGrp.getFirstAvail() as Flake;
              // we try to reuse flakes that are available in the group if we can.
              // we place our flakes randomly in a box that's much wider than the screen (because the wind can blow it on from the side)
              // and above the top of the screen.
              if (f != null)
                f.reset(Rnd.integer( -50, FlxG.width + 50), Rnd.integer( -15, -1));
              else
                flakeGrp.add(new Flake(Rnd.integer( -50, FlxG.width + 50), Rnd.integer( -15, -1)));
              f = null;
            }
          }
          else _throttle-= FlxG.elapsed;
        }
      }
      super.update();
    }
  }
}

package com.tileisle
{
import org.flixel.*;
public class SimpleState extends FlxState
{
private var _fxGroup:FXGroup;
private var _displacer:Displacement;

public function SimpleState()
{
super();
add(_fxGroup);
_fxGroup.add(_displacer = new Displacement(_fxGroup.FXBuffer, 10, 10, 20, 20, -10, 10, -10, 10, 2, 2, 0.5, 0.8, 1, 1));
}

override public function render():void
{
super.render();
_fxGroup.doRender(); // This MUST be called AFTER everything else is rendered, or it won't work.
}
}
}

package com.tileisle
{
import org.flixel.*;
import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.geom.Point;

/**
* <code>FXGroup</code> is a special FlxGroup which should only handle rendering effects.
*
* @author Ryan "Rybar" Malm, Tim "SeiferTim" Hely
*/
public class FXGroup extends FlxGroup
{
public var FXBuffer:BitmapData = new BitmapData(FlxG.width, FlxG.height);

public function FXGroup()
{

}

override public function render():void
{

}

/**
* Call <code>doRender</code> in the state's render function (after <code>super.render()</code>
*/
public function doRender():void
{
FXBuffer.copyPixels(FlxG.buffer, new Rectangle(0, 0, FlxG.width, FlxG.height), new Point(0, 0));
super.render();
}

}

}

package com.tileisle
{
import flash.display.BitmapData;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.sampler.NewObjectSample;
import org.flixel.*;
import com.gskinner.utils.Rnd;

/**
* <code>DisplaceBlob</code> is a <code>FlxSprite</code> object which copies from an area nearby to make a displacement effect.
* Usually emitted from the <code>Displacement</code> object, they can be added directly to the stage for neat effects.
*
* @author Ryan "Rybar" Malm, Tim "SeiferTim" Hely
*/
public class DisplaceBlob extends FlxSprite
{

private var blob:Rectangle;
private var StartSize:FlxPoint;
private var maxLife:Number = -1;
private var _displaceAmt:FlxPoint = new FlxPoint(1, 1);
private var _life:Number = -1;
private var Size:FlxPoint;
private var _buffer:BitmapData;

/**
* Use a <code>DisplaceBlob</code> to make an area on the screen displaced.
*
* @param  Buffer      This should point to your FXGroup's Buffer
* @param  X       The X position of the blob.
* @param  Y       The Y position of the blob.
* @param  Size      The size of the blob. 1-8 is valid. Defaults to 8.
* @param  Life      The lifespan of the blob. Defaults to -1 or, never dies.
* @param  DisplaceAmtX  How much displacement on the X axis to apply.
* @param  DisplaceAmtY  How much displacement on the Y axis to apply.
*/
public function DisplaceBlob(Buffer:BitmapData, X:Number, Y:Number, Width:Number = 1, Height:Number = 1, Life:Number = -1, DisplaceAmtX:Number = 1, DisplaceAmtY:Number = 1):void
{
_buffer = Buffer;
super(X, Y);
_displaceAmt = new FlxPoint(DisplaceAmtX,DisplaceAmtX);
if (Width &lt; 1) Width = 1;
if (Height &lt; 1) Height = 1;
StartSize = new FlxPoint(Width, Height);
Size = StartSize;
if (Life &lt; -1) Life = -1;
maxLife = Life;
createGraphic(Width, Height, 0xffffffff);
width = Width;
height = Height;
exists = false;
}

/**
* Call <code>rebuild</code> to reset the blob back to specific size and position.
*
* @param  X       The X position of the blob.
* @param  Y       The Y position of the blob.
* @param  Size      The size of the blob. 1-8 is valid..
* @param  Life      The lifespan of the blob. Defaults to -1 or, never dies.
* @param  DisplaceAmtX  How much displacement on the X axis to apply.
* @param  DisplaceAmtY  How much displacement on the Y axis to apply.
*/
public function rebuild(X:Number, Y:Number, Width:Number = 1, Height:Number = 1, Life:Number = -2, DisplaceAmtX:Number = 1, DisplaceAmtY:Number = 1):void
{
super.reset(X, Y);
_displaceAmt = new FlxPoint(DisplaceAmtX, DisplaceAmtX);
if (Width &lt; 2) Width = 2;
if (Height &lt; 2) Height = 2;
StartSize = new FlxPoint(Width, Height);
if (Life == -2) Life = maxLife;
else if (Life &lt; -1) Life = -1;
maxLife = Life;
Size = StartSize;
width = Width;
height = Height;
exists = false;
}

/**
* Set <code>blobWidth<code> to change how wide the blob is.
*/
public function get blobWidth():Number
{
return StartSize.x;
}</code></code>

/**
* Set <code>blobWidth<code> to change how wide the blob is.
*/
public function set blobWidth(Width:Number):void
{
if (Width &lt; 2) Width = 2;
StartSize.x = Width;
}</code></code>

/**
* Set <code>blobHeight<code> to change how wide the blob is.
*/
public function get blobHeight():Number
{
return StartSize.y;
}</code></code>

/**
* Set <code>blobHeight<code> to change how high the blob is.
*/
public function set blobHeight(Height:Number):void
{
if (Height &lt; 2) Height = 2;
StartSize.y = Height;
}</code></code>

/**
* Set <code>life</code> to set how long the blob lives. -1 to make the blob live forever.
*/
public function get life():Number
{
return maxLife;
}

/**
* Set <code>life</code> to set how long the blob lives. -1 to make the blob live forever.
*/
public function set life(Life:Number):void
{
if (Life &lt; -1) Life = -1;
maxLife = Life;
}

/**
* Set <code>displaceAmtX</code> to set the amount of displacement along the X axis.
*/
public function get displaceAmtX():Number
{
return _displaceAmt.x;
}

/**
* Set <code>displaceAmtX</code> to set the amount of displacement along the X axis.
*/
public function set displaceAmtX(Amt:Number):void
{
_displaceAmt.x = Amt;
}

/**
* Set <code>displaceAmtY</code> to set the amount of displacement along the Y axis.
*/
public function get displaceAmtY():Number
{
return _displaceAmt.y;
}

/**
* Set <code>displaceAmtY</code> to set the amount of displacement along the Y axis.
*/
public function set displaceAmtY(Amt:Number):void
{
_displaceAmt.y = Amt;
}

/**
* Set <code>displaceAmt</code> to set the amount of displacement along both axis.
*/
public function get displaceAmt():FlxPoint
{
return _displaceAmt;
}

/**
* Set <code>displaceAmt</code> to set the amount of displacement along both axis.
*/
public function set displaceAmt(Amt:FlxPoint):void
{
_displaceAmt = Amt;
}

override public function onEmit():void
{
super.onEmit();
Size = StartSize;
width = StartSize.x;
height = StartSize.y;
_life = maxLife;
exists = true;
}

override public function update():void
{
if (!exists) return;
super.update();

if (maxLife != -1)
{
if (_life &lt;= 0)
{
if (_life == -50)
{
Size.x -= 2;
Size.y -= 2;
if (Size.x &lt;= 0 || Size.y &lt;= 0) exists = false;
}
else
_life = -50;
}
else
_life-= FlxG.elapsed;
}
}

override public function render():void
{
if (!onScreen() || !exists) return;
var pnt:FlxPoint = getScreenXY();
var dx:Number = Rnd.float( -_displaceAmt.x, _displaceAmt.x);
var dy:Number = Rnd.float( -_displaceAmt.y, _displaceAmt.y);
var w:int = Size.x;
var h:int = Size.y;
FlxG.buffer.copyPixels(_buffer, new Rectangle(pnt.x + (w * .5), pnt.y + (h * .5), w, h), new Point(pnt.x + dx + (w * .5), pnt.y + dy + (h * .5)), _framePixels, null, true);
}
}

}

package com.tileisle
{
import flash.display.BitmapData;
import org.flixel.*;

/**
* <code>Displacement</code> is an emitter setup to work specifically with DisplaceBlobs.
*
* @author Ryan "Rybar" Malm, Tim "SeiferTim" Hely
*/
public class Displacement extends FlxEmitter
{
private var _life:Number = -1; // how long they live
private var _blobCount:uint = 100; // how many blobs will be created (determined by height/width)
private var _alpha:Number = 1; // alpha of the blobs
private var _displaceAmt:FlxPoint;
private var _blobSize:FlxPoint;
private var _buffer:BitmapData;

/**
* Creates a new <code>Displacement</code> object at a specific position.
*
* @param  Buffer      This should point to your FXGroup's Buffer
* @param  X       The X position of the emitter
* @param  Y       The Y position of the emitter
* @param  Width     The Width of the emitter
* @param  Height      The Height of the emitter
* @param  MinXSpeed   Minimum X Speed of particles emitted
* @param  MaxXSpeed   Maximum X Speed of particles emitted
* @param  MinYSpeed   Minimum Y Speed of particles emitted
* @param  MaxYSpeed   Maximum Y speed of particles emitted
* @param  BlobWidth   Width of emitted Blobs
* @param  BlobHeight    Height of emitted Blobs
* @param  Life      Lifespan of emitted Blobs
* @param  Alpha     Alpha of emitted Blobs
* @param  DisplaceAmtX  Amount of Displacement on X axis
* @param  DisplaceAmtY  Amount of Displacement on Y axis
*/
public function Displacement(Buffer:BitmapData, X:Number = 0, Y:Number = 0, Width:Number = 1, Height:Number = 1, MinXSpeed:Number = 1, MaxXSpeed:Number = 1, MinYSpeed:Number = 1, MaxYSpeed:Number = 1, BlobWidth:Number = 1, BlobHeight:Number = 1, BlobCount:int=50, Life:Number = 1, Alpha:Number = 1, DisplaceAmtX:Number = 1, DisplaceAmtY:Number = 1):void
{
_buffer = Buffer;
super(X, Y);
_displaceAmt = new FlxPoint(DisplaceAmtX, DisplaceAmtY);
if (BlobWidth &lt; 1) BlobWidth = 1;
if (BlobHeight &lt; 1) BlobHeight = 1;
_blobSize = new FlxPoint(BlobWidth, BlobHeight);
if (Alpha &gt; 1) Alpha = 1;
else if (Alpha &lt; 0.1) Alpha = 0.1;
_alpha = Alpha;
if (Life &lt; -1) Life = -1;
_life = Life;
setSize(Width, Height);
setXSpeed(MinXSpeed, MaxXSpeed);
setYSpeed(MinYSpeed, MaxYSpeed);
gravity = 0;
setBlobCount(_blobCount);
}

/**
* Use <code>setBlobCount</code> to set the number of blobs in your emitter. This will also rebuild it's buffer.
* @param  Count The number of blobs you want to have in your buffer.
*/
public function setBlobCount(Count:int):void
{
members.length = 0;
var d:DisplaceBlob;
for (var e:uint = 0; e &lt; Count; e++)
{
add(d = new DisplaceBlob(_buffer,0, 0, _blobSize.x, _blobSize.y, _life, _displaceAmt.x, _displaceAmt.y));
d.exists = false;
}
}

/**
* Set <code>blobWidth</code> to define the width of the emitted blobs
*/
public function get blobWidth():Number
{
return _blobSize.x;
}

/**
* Set <code>blobWidth</code> to define the width of the emitted blobs
*/
public function set blobWidth(Width:Number):void
{
if (Width &lt; 1) Width = 1;
_blobSize.x = Width;
}

/**
* Set <code>blobHeight</code> to define the height of the emitted blobs
*/
public function get blobHeight():Number
{
return _blobSize.y;
}

/**
* Set <code>blobHeight</code> to define the height of the emitted blobs
*/
public function set blobHeight(Height:Number):void
{
if (Height &lt; 1) Height = 1;
_blobSize.y = Height;
}

/**
* Set <code>blobSize</code> to define the size of the emitted blobs
*/
public function get blobSize():FlxPoint
{
return _blobSize;
}

/**
* Set <code>blobSize</code> to define the size of the emitted blobs
*/
public function set blobSize(Size:FlxPoint):void
{
if (Size.x &lt; 1) Size.x = 1;
if (Size.y &lt; 1) Size.y = 1;
_blobSize = Size;
}

/**
* Set <code>alpha</code> to set the alpha of the emitted blobs.
*/
public function get alpha():Number
{
return _alpha;
}

/**
* Set <code>alpha</code> to set the alpha of the emitted blobs.  Valid 0.1 - 1.
*/
public function set alpha(Alpha:Number):void
{
if (Alpha &gt; 1) Alpha = 1;
else if (Alpha &lt; 0.1) Alpha = 0.1;
_alpha = Alpha;
}

/**
* <code>blobCount</code> is the number of Blobs the system determined it will make for this displacement
*/
public function get blobCount():uint
{
return _blobCount;
}

public function set blobCount(BlobCount:uint):void
{
_blobCount = BlobCount;
setBlobCount(_blobCount);
}

/**
* Set <code>life</code> to determine the lifespan of emitted blobs
*/
public function get life():Number
{
return _life;
}

/**
* Set <code>life</code> to determine the lifespan of emitted blobs
*/
public function set life(Life:Number):void
{
if (Life &lt; -1) Life = -1;
_life = Life;
}

/**
* Set <code>displaceAmtX</code> to change the amount of displacement you want on the X axis.
*/
public function get displaceAmtX():Number
{
return _displaceAmt.x;
}

/**
* Set <code>displaceAmtX</code> to change the amount of displacement you want on the X axis.
*/
public function set displaceAmtX(Amt:Number):void
{
_displaceAmt.x = Amt;
}

/**
* Set <code>displaceAmtY</code> to change the amount of displacement you want on the Y axis.
*/
public function get displaceAmtY():Number
{
return _displaceAmt.y;
}

/**
* Set <code>displaceAmtY</code> to change the amount of displacement you want on the Y axis.
*/
public function set displaceAmtY(Amt:Number):void
{
_displaceAmt.y = Amt;
}

override protected function updateEmitter():void
{
if (!on || dead || !exists || !onScreen()) return;
for (var i:int = 0; i &lt;  int(_blobCount / (_life / FlxG.elapsed)); i++)
emitParticle();
}

/**
* Call this function to start emitting.
*/
public function begin():void
{
start(false, 1,0 );
}

/**
* Call this function to stop emitting.
*/
public function end():void
{
stop(0);
}

/**
* Call this function to reset the emitter
* @param  X The X position of the emitter
* @param  Y The Y position of the emitter
*/
override public function reset(X:Number, Y:Number):void
{
super.reset(X, Y);
for each (var e:DisplaceBlob in members) e.rebuild(0, 0, _blobSize.x, _blobSize.y, _life, _displaceAmt.x, _displaceAmt.y);
}

/**
* Call this function to spit out ONE particle.
*/
override public function emitParticle():void
{
if (!onScreen()) return;
_counter++;
var s:DisplaceBlob = getFirstAvail() as DisplaceBlob;
if (!s) return;
s.visible = true;
s.exists = true;
s.active = true;
s.alpha = _alpha;
s.blobWidth = _blobSize.x;
s.blobHeight = _blobSize.y;
s.life = _life;
s.displaceAmtX = _displaceAmt.x;
s.displaceAmtY = _displaceAmt.y;
s.x = x - (s.width &gt;&gt; 1) + FlxU.random() * width;
s.y = y - (s.height &gt;&gt; 1) + FlxU.random() * height;
s.velocity.x = minParticleSpeed.x;
if (minParticleSpeed.x != maxParticleSpeed.x) s.velocity.x += FlxU.random() * (maxParticleSpeed.x - minParticleSpeed.x);
s.velocity.y = minParticleSpeed.y;
if (minParticleSpeed.y != maxParticleSpeed.y) s.velocity.y += FlxU.random() * (maxParticleSpeed.y - minParticleSpeed.y);
s.acceleration.y = gravity;
s.angularVelocity = minRotation;
if (minRotation != maxRotation) s.angularVelocity += FlxU.random() * (maxRotation - minRotation);
if (s.angularVelocity != 0) s.angle = FlxU.random() * 360 - 180;
s.drag.x = particleDrag.x;
s.drag.y = particleDrag.y;
s.onEmit();
justEmitted = true;
}

public function emitRing(X:int, Y:int, Velocity:Number):void
{

for (var b:uint = 0; b &lt; members.length; b++)
{
var blob:DisplaceBlob = members[b] as DisplaceBlob;
var angleIncrement:Number = 360 / members.length;
if (!blob) return;
blob.visible = true;
blob.exists = true;
blob.active = true;
blob.alpha = _alpha;
blob.blobWidth = _blobSize.x;
blob.blobHeight = _blobSize.y;
blob.life = _life;
blob.displaceAmtX = _displaceAmt.x;
blob.displaceAmtY = _displaceAmt.y;
blob.x = X;
blob.y = Y;
blob.velocity.x = Math.sin(b*angleIncrement) * Velocity;
blob.velocity.y = Math.cos(b*angleIncrement) * Velocity;
blob.acceleration.y = gravity;
blob.drag.x = particleDrag.x;
blob.drag.y = particleDrag.y;
blob.onEmit();
}
justEmitted = true;
}
}

}