home *** CD-ROM | disk | FTP | other *** search
/ Ice Age Fan CD 1 / CD1_Scrat.iso / flash / data / game.swf / scripts / asCode / particleClass.as < prev    next >
Encoding:
Text File  |  2012-07-04  |  10.2 KB  |  372 lines
  1. package asCode
  2. {
  3.    import flash.display.Bitmap;
  4.    import flash.geom.Point;
  5.    
  6.    public class particleClass
  7.    {
  8.       public var lastX:Number;
  9.       
  10.       public var lastY:Number;
  11.       
  12.       public var x:Number;
  13.       
  14.       public var y:Number;
  15.       
  16.       private var bx:Number;
  17.       
  18.       private var by:Number;
  19.       
  20.       public var alive:Boolean;
  21.       
  22.       public var moving:Boolean;
  23.       
  24.       public var life:int;
  25.       
  26.       public var alphaVal:Number;
  27.       
  28.       public var dx:Number;
  29.       
  30.       public var dy:Number;
  31.       
  32.       public var gx:Number;
  33.       
  34.       public var gy:Number;
  35.       
  36.       public var reduceAlpha:Number;
  37.       
  38.       public var scale:Number;
  39.       
  40.       public var _speed:Number;
  41.       
  42.       private var rot:Number;
  43.       
  44.       private var radians:Number;
  45.       
  46.       private var angle:Number;
  47.       
  48.       private var sheetX:Number;
  49.       
  50.       private var sheetY:Number;
  51.       
  52.       private var xSize:Number;
  53.       
  54.       private var ySize:Number;
  55.       
  56.       public var bitmapRef:Bitmap;
  57.       
  58.       public var particleType:int;
  59.       
  60.       public var baseAlpha:Number;
  61.       
  62.       private var P_ELECTRICAL:int = 1;
  63.       
  64.       private var P_WANDERING_LINE:int = 2;
  65.       
  66.       private var P_LINE:int = 3;
  67.       
  68.       private var P_FALLING:int = 4;
  69.       
  70.       private var P_WANDERING:int = 5;
  71.       
  72.       private var P_GROWING:int = 6;
  73.       
  74.       private var P_WHITE_SMOKE:int = 7;
  75.       
  76.       private var P_METEOR:int = 8;
  77.       
  78.       private var P_BLUE_FLASH:int = 9;
  79.       
  80.       private var P_FLASH:int = 10;
  81.       
  82.       private var P_FLICKER:int = 11;
  83.       
  84.       private var P_SNOW:int = 12;
  85.       
  86.       public var xpos:int;
  87.       
  88.       private var returnPoint:Point;
  89.       
  90.       private var sheetLoc:Point;
  91.       
  92.       public function particleClass(param1:int, param2:int, param3:int, param4:Number, param5:Number, param6:*, param7:*)
  93.       {
  94.          returnPoint = new Point();
  95.          sheetLoc = new Point();
  96.          super();
  97.          particleType = param3;
  98.          lastX = x = param1;
  99.          lastY = y = param2;
  100.          alive = true;
  101.          xSize = param4;
  102.          ySize = param5;
  103.          life = 60;
  104.          sheetX = param6;
  105.          sheetY = param7;
  106.          sheetLoc.x = sheetX;
  107.          sheetLoc.y = sheetY;
  108.          alphaVal = 1;
  109.          rot = Math.random() * Math.PI;
  110.          baseAlpha = 1;
  111.          moving = true;
  112.          scale = 1;
  113.          var _loc8_:Number = Math.random() * 360;
  114.          var _loc9_:Number = 2;
  115.          var _loc10_:Number = 90;
  116.          reduceAlpha = 0;
  117.          _speed = 2;
  118.          angle = Math.random() * 360;
  119.          switch(particleType)
  120.          {
  121.             case P_SNOW:
  122.                life = 100;
  123.                angle = 90 + Math.random() * 3;
  124.                scale = Math.random() * 1 + 0.5;
  125.                _speed = Math.random() * 0.8 + 0.5;
  126.                _loc9_ = 0;
  127.                reduceAlpha = 1 / life;
  128.                break;
  129.             case P_ELECTRICAL:
  130.                angle = Math.random() * 360;
  131.                scale = Math.random() * 1 + 0.5;
  132.                _speed = 2;
  133.                _loc9_ = 0.2;
  134.                life = 20;
  135.                _loc9_ = 0;
  136.                reduceAlpha = 1 / life;
  137.                break;
  138.             case P_WANDERING_LINE:
  139.                angle = Math.random() * 360;
  140.                scale = Math.random() * 1 + 0.5;
  141.                _speed = Math.random() * 3 + 1;
  142.                _loc9_ = 0.2;
  143.                life = 90;
  144.                reduceAlpha = 1 / life;
  145.                break;
  146.             case P_LINE:
  147.                angle = Math.random() * 360;
  148.                scale = Math.random() * 0.5 + 0.2;
  149.                if(Math.random() * 10 < 2)
  150.                {
  151.                   _speed = Math.random() * 5 + 3;
  152.                }
  153.                else
  154.                {
  155.                   _speed = Math.random() * 3 + 1;
  156.                }
  157.                _loc9_ = 0.2;
  158.                life = 90;
  159.                reduceAlpha = 1 / life;
  160.                break;
  161.             case P_FALLING:
  162.                angle = Math.random() * 360;
  163.                scale = Math.random() * 1 + 0.5;
  164.                _speed = Math.random() * 5 + 1;
  165.                _loc9_ = 0.2;
  166.                break;
  167.             case P_WANDERING:
  168.                life = 30;
  169.                _loc9_ = 0;
  170.                reduceAlpha = 1 / life;
  171.                _speed = Math.random() * 2 + 0.2;
  172.                _loc8_ = Math.random() * 45 - 90 - 22;
  173.                break;
  174.             case P_GROWING:
  175.                _loc9_ = 0;
  176.                _speed = 0;
  177.                life = 30;
  178.                reduceAlpha = 1 / life;
  179.                rot = Math.random() * 360;
  180.                break;
  181.             case P_WHITE_SMOKE:
  182.                alphaVal = 0.5;
  183.                life = 30;
  184.                _speed = 3;
  185.                _loc9_ = 0;
  186.                x += Math.floor(Math.random() * 10 - 5);
  187.                angle = -90 + Math.random() * 10 - 5;
  188.                reduceAlpha = alphaVal / life;
  189.                scale = Math.random() * 1 + 1;
  190.                break;
  191.             case P_METEOR:
  192.                alphaVal = 0.5;
  193.                life = 30;
  194.                _speed = 1;
  195.                _loc9_ = 0;
  196.                x += Math.floor(Math.random() * 10 - 5);
  197.                angle = -90 + Math.random() * 10 - 5;
  198.                reduceAlpha = alphaVal / life;
  199.                scale = Math.random() * 1 + 1;
  200.                break;
  201.             case P_BLUE_FLASH:
  202.                _loc9_ = 0;
  203.                _speed = 0;
  204.                angle = 0;
  205.                alphaVal = 0.75;
  206.                break;
  207.             case P_FLASH:
  208.                _loc9_ = 0;
  209.                _speed = 0;
  210.                angle = Math.random() * 360;
  211.                alphaVal = 0.75;
  212.                scale = Math.random() * 1 + 0.5;
  213.                break;
  214.             case P_FLICKER:
  215.                _loc9_ = 0;
  216.                _speed = 0;
  217.                angle = 0;
  218.                scale = Math.random() * 1 + 0.5;
  219.                x += Math.floor(Math.random() * 10 - 5);
  220.                y += Math.floor(Math.random() * 10 - 5);
  221.          }
  222.          radians = _loc10_ * Math.PI / 180;
  223.          gx = _loc9_ * Math.cos(radians);
  224.          gy = _loc9_ * Math.sin(radians);
  225.          radians = angle * Math.PI / 180;
  226.          bx = _speed * Math.cos(radians);
  227.          by = _speed * Math.sin(radians);
  228.       }
  229.       
  230.       public function getParticleType() : int
  231.       {
  232.          return particleType;
  233.       }
  234.       
  235.       public function getSheetloc() : Point
  236.       {
  237.          return sheetLoc;
  238.       }
  239.       
  240.       public function getScale() : Number
  241.       {
  242.          return scale;
  243.       }
  244.       
  245.       public function getSize() : Point
  246.       {
  247.          returnPoint.x = xSize;
  248.          returnPoint.y = ySize;
  249.          return returnPoint;
  250.       }
  251.       
  252.       public function getAlpha() : Number
  253.       {
  254.          return alphaVal;
  255.       }
  256.       
  257.       public function getRot() : Number
  258.       {
  259.          return rot;
  260.       }
  261.       
  262.       public function getLoc() : Point
  263.       {
  264.          returnPoint.x = x - xSize / 2;
  265.          returnPoint.y = y - ySize / 2;
  266.          return returnPoint;
  267.       }
  268.       
  269.       public function adjustParticleY(param1:Number) : *
  270.       {
  271.          if(particleType != P_ELECTRICAL)
  272.          {
  273.             y += param1;
  274.          }
  275.       }
  276.       
  277.       public function effectParticle(param1:*, param2:*) : *
  278.       {
  279.          x += param1;
  280.          y += param2;
  281.       }
  282.       
  283.       public function moveit() : *
  284.       {
  285.          if(alive)
  286.          {
  287.             --life;
  288.             if(life < 1)
  289.             {
  290.                alive = false;
  291.             }
  292.             switch(particleType)
  293.             {
  294.                case P_SNOW:
  295.                   gx = Math.random() * 0.3 - 0.15;
  296.                   break;
  297.                case P_ELECTRICAL:
  298.                   dx = x - lastX;
  299.                   dy = y - lastY;
  300.                   radians = Math.atan2(dy,dx);
  301.                   rot = radians * 180 / Math.PI;
  302.                   break;
  303.                case P_WANDERING_LINE:
  304.                   gx = Math.random() * 1 - 0.5;
  305.                   gy = Math.random() * 1 - 0.5;
  306.                   dx = x - lastX;
  307.                   dy = y - lastY;
  308.                   radians = Math.atan2(dy,dx);
  309.                   rot = radians * 180 / Math.PI;
  310.                   break;
  311.                case P_LINE:
  312.                   dx = lastX - x;
  313.                   dy = lastY - y;
  314.                   radians = Math.atan2(dy,dx);
  315.                   rot = radians * 180 / Math.PI;
  316.                   break;
  317.                case P_FALLING:
  318.                   rot += 2;
  319.                   break;
  320.                case P_WANDERING:
  321.                   gx = Math.random() * 0.1 - 0.05;
  322.                   gy = Math.random() * 0.1 - 0.05;
  323.                   break;
  324.                case P_GROWING:
  325.                   scale *= 1.01;
  326.                   break;
  327.                case P_BLUE_FLASH:
  328.                   alphaVal = Math.random() * baseAlpha;
  329.                   baseAlpha -= 0.2;
  330.                   break;
  331.                case P_FLASH:
  332.                   alphaVal = Math.random() * baseAlpha;
  333.                   baseAlpha -= 0.2;
  334.                   break;
  335.                case P_FLICKER:
  336.                   alphaVal = Math.random() * baseAlpha;
  337.                   baseAlpha -= 0.02;
  338.                   break;
  339.                case P_WHITE_SMOKE:
  340.                   scale *= 1.01;
  341.                   break;
  342.                case P_METEOR:
  343.                   scale *= 0.97;
  344.             }
  345.             if(y > 480 || y < 0 || x > 480 || x < 0)
  346.             {
  347.                alive = false;
  348.             }
  349.             lastX = x;
  350.             lastY = y;
  351.             x += bx;
  352.             y += by;
  353.             bx += gx;
  354.             by += gy;
  355.             if(Math.abs(bx) < 0.1 && Math.abs(by) < 0.1)
  356.             {
  357.                moving = false;
  358.             }
  359.             if(reduceAlpha != 0)
  360.             {
  361.                alphaVal -= reduceAlpha;
  362.                if(alphaVal < 0.05)
  363.                {
  364.                   alive = false;
  365.                }
  366.             }
  367.          }
  368.       }
  369.    }
  370. }
  371.  
  372.